#### Transcript SKIP GRAPHS (Joint work with James Aspnes: SODA 2003)

```SKIP LISTS [Pugh ’90]
Some slides adapted from the original slides by
James Aspnes
Gauri Shah
2
Definition of Skip List
A skip list for a set L of distinct (key, element) items is
a series of linked lists L0, L1 , … , Lh such that
Each list Li contains the special keys + and -
List L0 contains the keys of L in no-decreasing order
Each list is a subsequence of the previous one, i.e.,
L0  L1  …  Lh
List Lh contains only the two special keys + and -
3
Skip List
Dictionary based on a probabilistic data structure.
Allows efficient search, insert, and delete operations.
Each element in the dictionary typically stores additional
useful information beside its search key. Example:
<student id. Transcripts>
<date, news>
[for University of Iowa]
[for Daily Iowan]
Probabilistic alternative to a balanced tree.
4
Skip List
TAIL
Level 0
Level 1
Level 2
J
-
A
A
G
+
J
M
J
M
R
W
Each node linked at higher level with probability 1/2.
5
Another example
L2
-
L1
-
L0
-
+
31
23
12
23
26
31
34
31
34
+
64
44
56
64
78
+
Each element of Li appears in L.i+1 with probability p.
Higher levels denote express lanes.
Searching in Skip List
Search for a key x in a skip list as follows:
Start at the first position of the top list
At the current position P, compare x with y  key(after(p))
x = y -> return element(after (P))
x > y -> “scan forward”
x < y -> “drop down”
– If we move past the bottom list, then no such key
exists
6
Example of search for 78
L3
-
L2
-
L1
-
L0
-
+
+
31
23
12
23
26
31
34
31
34
+
64
44
56
64
78
+
At L1 P is 64, at,+ is bigger than 78, we drop down
At L0, 78 = 78, so the search is over.
7
Insertion
• The insert algorithm uses randomization to
decide in how many levels the new item <k>
should be added to the skip list.
• After inserting the new item at the bottom
level flip a coin.
• If it returns tail, insertion is complete.
Otherwise, move to next higher level and insert
<k> in this level at the appropriate position, and
repeat the coin flip.
8
9
Insertion Example
1) Suppose we want to insert 15
2) Do a search, and find the spot between 10 and 23
3) Suppose the coin come up “head” three times
p2
L2 -
p1
L1 -
L0 -
L3 -
23
p0
10
23
36
+
+
L2 -
15
+
L1 -
15
23
+
L0 -
15
23
10
+
+
36
+
Deletion
• Search for the given key <k>. If a position with key
• Otherwise, if a position with key <k> is found (it
will be definitely found on the bottom level), then
we remove all occurrences of <k> from every level.
• If the uppermost level is empty, remove it.
10
11
Deletion Example
1) Suppose we want to delete 34
2) Do a search, find the spot between 23 and 45
3) Remove all the position above p
Remove this level
p2
L2 -
34
p1
L1 -
L0 -
23
34
p0
12
23
34
45
+
L2 -
+
L1 -
+
L0 -
+
+
23
12
23
45
+
12
Constant number of pointers
Average number of pointers per node = O(1)
Total number of pointers
= 2.n + 2. n/2 + 2. n/4 + 2. n/8 + …
= 4.n
So, the average number of pointers per node = 4
13
Number of levels
The number of levels = O(log n) w.h.p
Pr[a given element x is above level c log n]
= 1/2c log n
= 1/nc
Pr[any element is above level c log n] = n. 1/nc
= 1/nc-1
14
Search time
Consider a skiplist with two levels L0 and L1. To search
a key, first search L1 and then search L0.
Cost (i.e. search time) = length (L1) + n / length (L1)
Minimum when length (L1) = n / length (L1).
Thus length(L1) = (n) 1/2, and cost = 2. (n) 1/2
(Three lists) minimum cost = 3. (n)1/3
(Log n lists) minimum cost = log n. (n) 1/log n = 2.log n
15
Skip lists for P2P?
• O(log n) expected search time.
• Retains locality.
• Easily susceptible to failures.
• Lacks redundancy.
16
Look back at DHT
Nodes
v4
Keys
Virtual
Route
v2
v1
HASH
Physical
Actual Route
PHYSICAL NETWORK
v1 v2 v3 v4
Virtual
v3
VIRTUAL OVERLAY
NETWORK
17
Level 2
A Skip Graph
A
100
Level 1
000
Level 0
W
G
100
J
M
R
001
011
110
G
A
J
M
001
001
011
101
R
W
110
101
Membership vectors
A
G
J
M
R
W
001
100
001
011
110
101
Link at level i to nodes with matching prefix of length i.
Think of a tree of skip lists that share lower layers.
18
Properties of skip graphs
1. Efficient Searching.
2. Efficient node insertions & deletions.
3. Independence from system size.
4. Locality and range queries.
19
Searching: avg. O (log n)
Level 0
Level 1
Level 2
Restricting to the lists containing the starting
element of the search, we get a skip list.
A
A
A
G
G
G
J
M
J
M
J
M
R
W
R
W
R
W
Same performance as DHTs.
20
Node Insertion – 1
Level 2
buddy
G
A
100
Level 1
000
011
A
100
R
101
001
110
R
W
110
101
M
R
W
011
110
101
G
001
Level 0
M
W
new node
J
M
011
A
G
001
100
Starting at buddy node, find nearest key at level 0.
Takes O(log n) time on average.
21
Node Insertion - 2
Level 2
At each level i, find nearest node with matching
prefix of membership vector of length i+1.
A
100
Level 1
000
J
M
001
011
G
A
100
001
Level 0
W
G
A
G
001
100
R
101
110
R
W
110
101
W
J
M
001
011
J
M
R
001
011
110
101
Total time for insertion: O(log n)
DHTs take: O(log2n)
22
Independent of system size
No need to know size of keyspace or number of nodes.
Level 1
Level 0
E
Z
E
Z
1
0
insert
J
E
J
Z
Level 2
E
J
Z
00
01
Level 1
E
J
Z
1
0
0
Level 0
Old nodes extend membership vector as required with arrivals.
DHTs require knowledge of keyspace size initially.
23
Locality and range queries
• Find key < F, > F.
• Find largest key < x.
• Find least key > x.
D
A
F
I
• Find all keys in interval [D..O].
A
D
F
I
L
• Initial node insertion at level 0.
O
S
24
Applications of locality
Version Control
e.g. find latest news from yesterday.
find largest key < news: 02/13.
Level 0
news:02/09
news:02/10
news:02/11
news:02/12
news:02/13
Data Replication
e.g. find any copy of some Britney Spears song.
Level 0
britney01
britney02
britney03
britney04
britney05
DHTs cannot do this easily as hashing destroys locality.
25
So far...
Decentralization.
Locality properties.
O(log n) space per node.

O(log n) search, insert, and

delete time.
Independent of system size.
Coming up...
•Tolerance to faults.
• Random faults.
• Self-stabilization.
26
Interested in average load on a node u.
i.e. the number of searches from source
s to destination t that use node u.
Theorem: Let dist (u, t) = d. Then the
probability that a search from s to t passes
through u is < 2/(d+1).
where V = {nodes v: u <= v <= t} and |V| = d+1.
27
Skip list restriction
Level 2
Level 1
s
Nodes u
Level 0
Node u is on the search path from s to t only if it is in
the skip list formed from the lists of s at each level.
28
Tallest nodes
s
u is not on path.
s

u is on path.
u
u
u
t
u
u
t
Node u is on the search path from s to t only if it is
in T = the set of k tallest nodes in [u..t].
d+1
Pr [u εT] =  Pr[|T|=k] • k/(d+1) = E[|T|]/(d+1).
k=1
Heights independent of position, so distances are symmetric.
```