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!