Abstract キーの値による範囲検索が可能なキー順序保存型構造化オーバレイネットワークは多くの応用があり，重要性が高い．本研究では，新しいキー順序保存型構造化オーバレイネットワークSuzakuを提案する．Suzakuは，(1)Churn時でも最大検索ホップ数がlog_2 n程度に収まる（nはノード数），(2)キーが大小どちらの方向でも近傍ノードの検索は高速に行える，(3)構造は単純で実装が容易，といった特徴を備える．本稿ではSuzakuの詳細について述べ，シミュレーションによって既存のChord#およびSkip Graphと比較する． A ``key-order preserving structured overlay network,'' which enables range queries, has various applications and thus be important. In this study, we propose a novel key-order preserving structured overlay network ``Suzaku,'' which has the following properties: (1) maximum lookup hops is almost log_2 n even in churn situations, where $n$ is the number of nodes, (2) neighbor search is fast regardless of the direction of their keys, (3) the structure is simple and easy to implement. In this paper, we describe the principles and detailed algorithm of Suzaku. We also show simulation results comparing Suzaku with existing Chord# and Skip Graph.

1.
1

2.
2
[50, 80)
38

3.
3

4.
4

5.
5
Sucessor
=
Predecessor
=
N0
N4N12
N8
N14 N2
N10 N6
N15
N3
N11
N7
N13
N1
N9
N5

6. O(n)
O(log n)
6
+1 N1 12
+2 N2 25
+4 N4 36
+8 N8 50
N0 Finger Table
+2
+4
+8
+1
N0
N4N12
N8
N14 N2
N10 N6
N15
N3
N11
N7
N13
N1
N9
N5

7.
7
+1 N1
+2 N2
+4 N4
+8 N8
N0 Finger Table
N0
N4N12
N8
N14 N2
N10 N6
N15
N3
N11
N7
N13
N1
N9
N5
N2
N4
N0
N8

8. 8
Chord#
( )
⌈log2n⌉
( )
O(n)

9. i i
9
key
MV
148
21
21 33
7 21 33 148 275 399
7 33
275 399
275 399
148 275 399
7 148
7
LEVEL 0
LEVEL 1
LEVEL 2
LEVEL 3
N1
001
N2
10
N3
01
N4
000
N5
110
N6
111

10. 10
Chord# Skip Graph
( )
⌈log2n⌉ O(log2n)
( )
O(n) ⌈log2n⌉

11.
11

12. 12
Chord# Skip Graph Suzaku
( )
⌈log2n⌉ O(log2n) ⌈log2n-1⌉
( )
O(n) ⌈log2n⌉ log2n

13. 13

14. 14
LEVEL 0
LEVEL 1
LEVEL 2
LEVEL 3
N1 N2 N3 N4 N5 N6

15.
15
N0
N4N12
N8
N14 N2
N10 N6
N15
N3
N11
N7
N13
N1
N9
N5
BFT FFT
+1 N1
+2 N2
+4 N4
+8 N8
N0 FFT
-1 N15
-2 N14
-4 N12
-8 N8
N0 BFT

16. N13
16
N0
N4N12
N8
N14 N2
N10 N6
N15
N3
N11
N7
N1
N9
N5
BFT FFT
+1 N1
+2 N2
+4 N4
+8 N8
N0 FFT
-1 N15
-2 N14
-4 N12➡N11
-8 N8
N0 BFT

17.
17
N0
N4N12
N8
N14 N2
N10 N6
N15
N3
N11
N7
N13
N1
N9
N5
BFT FFT
+1 N1
+2 N2
+4 N4
+8 N8
N0 FFT
-1 N15
-2 N14
-4 N12
-8 N8
N0 BFT

18.
18

19. x x
19
N0
N4N12
N8
N14 N2
N10 N6
N15
N3
N11
N7
N13
N1
N9
N5
BFT FFT
+1 N1
+2 N2
+4 N4
+8 N8
N0 FFT
-1 N15
-2 N14
-4 N12
-8 N8
N0 BFT

20.
p
p
p p
20
N0 N8FFT[3]
Reverse Pointer
N4 FFT[2]
N7
N0
N8
FFT[3]
!
N4
FFT[2]

21.
21
getEnt
N0 (new) N1 N2 N4N7N6N4
FFT[2] FFT[1]
getEnt
getEnt
getEnt
N2
N6
N4
N4
N1
N7
lev0lev0
getEnt
BFT[1]
getEnt
FFT[1]
BFT[1]
BFT[2]
FFT[2]
FFT[1]
FFT[3]
FFT[2]
BFT[2]
N3N5
SuccPred

22. getEnt
N0 (new) N1 N2 N4N7N6N4
FFT[1]
N2
N4
N1
getEnt
BFT[1]
getEnt
FFT[2]
BFT[2]
N3N5
wait
wait
wait
22

23. 23

24.
24

25.
25
0
5
10
15
20
25
0 5 10 15 20
#ofhops(ave.)
time elapsed (min)
Chord#
Skip Graph
Suzaku

26. 26
0
0.05
0.1
0.15
0.2
0.25
0.3
0 10 20 30 40 50
freq.
# of hops (after insertion)
0 2 4 6 8 10 12 14 16 18
# of hops (converged)
Chord#
Skip Graph
Suzaku

27. 27
0
0.2
0.4
0.6
0.8
1
0 10 20 30 40 50 60 70
lookupretryratio
time elapsed since massive deletion (sec)
Chord#
Skip Graph
Suzaku

28. 28
0
2
4
6
8
10
12
14
-64-48-32-16 0 16 32 48 64
#ofhops
dist. to node (Skip Graph)
0
10
20
30
40
50
60
70
-64-48-32-16 0 16 32 48 64
dist. to node (Chord#)
after insertion
converged
0
1
2
3
4
5
6
7
8
-64-48-32-16 0 16 32 48 64
dist. to node (Suzaku)
after insertion
converged

29.
29

30. 30
Chord# Skip Graph Suzaku
( )
⌈log2
n⌉ O(log2
n) ⌈log2
n-1⌉
( )
O(n)
⌈log2
n⌉
log2
n

31. 31
Chord# Skip Graph Suzaku
( )
⌈log
2
n⌉ O(log2
n) ⌈log
2
n-1⌉
( )
O(n) ⌈log2
n⌉ log2
n
😥

32. 32

33. 33
1 const FFT = 0 , BFT = 1;
2 // ft [FFT] is FFT, ft [BFT] is BFT
3 // ft [FFT][0] = successor , ft [BFT][0] = predecessor
4 var f t [ 2 ] [ ] : Array of {Array of NodeAndKey };
5 var R: Set of NodeAndKey ; // reverse pointers
6 n . updateBoth ( dir , i , n1 , n2 ) {
7 tab ← f t [ d i r ] ;
8 i f ( i = 0) n1 ← f t [ d i r ] [ 0 ] ; // succ or pred
9 i f ( n1 = null or n1 = n ) {
10 x ← null ; goto next ;
11 }
12 i f ( d i r = FFT ) {y ← n2 ;} e l s e {y ← f t [ FFT ] [ i ] ; }
13 x ← n1 . getEnt ( dir , i , n , y ) ;
14 i f ( n1 f a i l e d ) { we omit the detail of this case }
15 i f ( i |= 0) change ( tab , i , n1 , true ) ; // active update
16 i f ( ( d i r = FFT and x ∈ [ n , tab [ i ] ] ) or
17 ( d i r = BFT and x ∈ [ tab [ i ] , n ] ) ) x ← null ; // circulated
18 next :
19 i f ( x = null and n2 = null ) return ;
20 i f ( d i r = FFT ) { n . updateBoth (BFT , i , n2 , x ) ; }
21 e l s e { n . updateBoth (FFT , i + 1 , n2 , x ) ; }
22 }
23 n . updateFFT ( i , n1 ) {
24 i f ( i = 0) n1 ← f t [ FFT ] [ 0 ] ; // successor
25 x ← n1 . getEnt (FFT , i , n , null ) ;
26 i f ( n1 f a i l e d ) { we omit the detail of this case }
27 i f ( i |= 0) change ( f t [ FFT ] , i , n1 , true ) ; // active update
28 i f ( x ∈ [ n , f t [ FFT ] [ i ] ] ) { // circulated
29 // truncate FFT and BFT to size i
30 for ( j ← i to f t [ FFT ] . length −1) change ( f t [ FFT ] , i , null , f a l s e ) ;
31 for ( j ← i to f t [BFT ] . length −1) change ( f t [BFT] , i , null , f a l s e ) ;
32 s l e e p (Tft ) ;
33 n . updateFFT (0 , null ) ;
34 } e l s e {
35 s l e e p (Tft ) ;
36 n . updateFFT ( i + 1 , x ) ;
37 }
38 }
39 n . getEnt ( dir , l e v e l , p , q ) {
40 i f ( l e v e l |= 0) {
41 change ( f t [1 − d i r ] , l e v e l , p , true ) ; // pasv. update 1
42 }
43 i f ( q |= null ) {
44 i f ( d i r = BFT) {
45 change ( f t [1− d i r ] , l e v e l +1 , q , f a l s e ) ; // pasv. update 2
46 } e l s e R ← R ∪ {q };
47 }
48 return f t [ d i r ] [ l e v e l ] ;
49 }
50 n . change ( tab , l e v e l , new , addtorev ) {
51 old ← tab [ l e v e l ] ;
52 tab [ l e v e l ] ← new ;
53 i f ( addtorev and new |= null ) R ← R ∪ {new };
54 i f ( old |= null and (FFT and BFT do not contain old ) ) {
55 old . removeRev ( n ) ;
56 }
57 }
58 n . removeRev ( p ) {
59 R ← R {p };
60 }
0
5
10
15
20
25
0 5 10 15
#ofhops(ave.)
time elapsed (min)
Chord#
Skip Graph
Suzaku
3
Fig. 3 Changes of # of lookup hops.
0
0.05
0.1
0.15
0.2
0.25
0.3
0 10 20 30 40 50
freq.
# of hops (after insertion)
0 2 4 6 8 10 12
# of hops (converge
Chord#
Skip Graph
Suzaku
4
Fig. 4 Distribution of lookup hops.
0
0.2
0.4
0.6
0.8
1
0 10 20 30 40 50 60
lookupretryratio
time elapsed since massive deletion (sec)
Chord#
Skip Graph
Suzaku
5
Fig. 5 Lookup retry ratio in massive node deletion
Chord#
51
Suzaku 10
Chord#
8 (= ⌈log2 256⌉) Suza
7(= ⌈log2 256⌉ − 1)
Skip Graph 17
Chord#
fing
Suzaku
Chord#
Skip G
Suzaku