self-tuning reactive distributed trees for counting and balancing phuong hoai ha marina...
Post on 21-Dec-2015
215 Views
Preview:
TRANSCRIPT
Self-tuning Reactive Distributed Trees for Counting and Balancing
Phuong Hoai HaMarina Papatriantafilou Philippas Tsigas
OPODIS ’04, Grenoble, FranceDec. 15 – 17, 2004
OPODIS '04 2
Schedule
• Introduction– Coordinating Objects– Reactive Shared Objects
• Self-tuning Reactive Trees– Algorithms– Evaluation
• Conclusions
OPODIS '04 3
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
OPODIS '04 4
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++)
OPODIS '04 5
Schedule
• Introduction– Coordinating Objects– Reactive Shared Objects
• Self-tuning Reactive Trees– Algorithms– Evaluation
• Conclusions
OPODIS '04 6
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.
OPODIS '04 7
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
C6B1
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++)
OPODIS '04 8
Reactive policy
OPODIS '04 9
Schedule
• Introduction– Coordinating Objects– Reactive Shared Objects
• Self-tuning Reactive Trees– Algorithms– Evaluation
• Conclusions
OPODIS '04 10
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.
OPODIS '04 11
Reactive policy• Problem: balancing the trade-off between two key measures,
the contention level and the depth of the tree.
OPODIS '04 12
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
OPODIS '04 13
Expanding a leaf to a subtree
IN
2
3
5
8
12
6
10
2 pending processor
s
OPODIS '04 14
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
OPODIS '04 15
Results: Full contention benchmark
Throughput
0
2
4
6
8
10
12
14
16
4 8 12 16 20 24 28 32#processors
Pro
po
rtio
n o
f ST
-tre
e to
RD
-tre
e
RD-tree ST-tree
Average depth
0
0.5
1
1.5
2
2.5
3
3.5
4 8 12 16 20 24 28 32#processors
Av
era
ge
de
pth
RD-tree ST-tree
OPODIS '04 16
Results: Index distribution benchmarkThroughput
0
5
10
15
20
25
30
35
40
45
4 8 12 16 20 24 28 32#processors
Pro
po
rtio
n o
f S
T-t
ree
to R
D-t
ree
RD-tree ST-tree
Average depth
0
0.5
1
1.5
2
2.5
3
3.5
4 8 12 16 20 24 28 32#processors
Av
era
ge
de
pth
RD-tree ST-tree
OPODIS '04 17
Results: Surge load benchmark
Average depth
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5
4000
4568
5136
5704
6272
6840
7408
7976
8544
9112
9680
1024
8
1081
6
1138
4
1195
2
1252
0
1308
8
1365
6
1422
4
1479
2
#intervals
Ave
rag
e d
epth
ST-tree RD-tree
OPODIS '04 18
Schedule
• Introduction– Coordinating Objects– Reactive Shared Objects
• Self-tuning Reactive Trees– Algorithms– Evaluation
• Conclusions
OPODIS '04 19
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.
OPODIS '04 20
Thank you!
top related