Evidencias adicionales a partir de medidas Raman Conclusiones micro-estructurales.

In a one-dimensional overlay structure like a ring, routing needs O(n) hops on av- erage. This linear routing performance does not scale in general. Assuming every node sends one message in a given time frame, each of which will be forwarded O(n) times by other nodes then O(n2) messages will be transferred on the link layer. On average, every node will have to transfer O(n) messages. This means the traffic on one node increases linearly with the number of nodes.

Therefore, peer-to-peer overlays usually feature an additional structure connecting nodes far away from each other in the key space. This allows a node to bridge a much larger key space distance in one hop when routing a message. Thus, routing

4.2 Overlay Structure 53

Figure 4.4: Pastry routing table, b=4, l=6

paths become shorter and the traffic per node is reduced. For example, Chord and Pastry both feature a routing path length of O(log(n)).

Each node stores the set of nodes providing these additional long distance connec- tions in a routing table. Our routing table is heavily inspired by the routing table of Pastry adapting it for two dimensions. Pastry features a two-dimensional routing table with b columns and l rows where b is the radix used in the key space and l is the length of keys in digits. The size of the key space is N = bl_{. A routing table}

entry e_i,j is defined by its column i, 0≤ i < b and its row j, 0 ≤ j < l. For a node

c with ID c0c1...cl−1 and a node d showing up in entry ei,j, d’s ID d0...dl−1 has to

fulfil a certain constraint. It must match c’s ID in the first j digits c0...cj−1. Then,

digit j must equal i. The remaining digits are not constrained. Therefore, d’s ID must be of the form d = c0...cj−1i∗. In the first row with j = 0, the constraint

effectively means that a node in column i starts with i. All nodes in the second row start with c0 and have the column number i as the second digit. All nodes in the

third row start with c0c1 with the column number i as the third digit. The entry

e_cj,j is left blank for all j = 0...l− 1. So in every row j the column number equalling the node ID in digit j is not occupied. This entry would contain a node with ID

c0...cj−1i. Since i = cj, it would be c0...cj−1cj. However, nodes matching c’s ID in

the first j + 1 digits are found in the next lower row j + 1. Therefore, the entries e_cj,j are not needed. Entries can also be empty if no node with a matching constraint exists. This is highly likely for lower rows as the key space is usually only sparsely populated with nodes. Figure 4.4 shows an example of a Pastry routing table. This kind of routing table allows a prefix routing scheme to be used yielding O(log(n)) routing performance. For a message destination t = t0...tl−1, even in the worst case c

will have a routing table entry matching t in the first digit because c has nodes in its first row with all possible digits. Assuming d is that entry, d’s ID will be t0d1...dl−1.

Now d will also have an entry in its second row matching t in the first two digits because d has all possible digits in its second row. This means even in the worst case, this routing procedure allows a message to get closer to its destination with

54 Chapter 4 A Self-Stabilizing Delaunay Overlay

Figure 4.5: Three layers of a routing table with_bx = 4 and_by = 4

each hop matching the destination in one more digit. The maximum number of hops is l. With l = logbN , the worst case routing performance depends logarithmically

on the size of the key space. If the n nodes are evenly distributed in the key space, routing will take O(logbn) steps.

Applying this scheme to two dimensions, we use a three-dimensional routing table with b_x columns, b_y rows, and l layers. Figure 4.5 shows how the first three layers contain nodes from different areas of the key space. For our key space K = K_x×K_y,

b_x is the base of the numbers used for the integer part of the x-coordinate and b_y is the base of the numbers used for the integer part of the y-coordinate. The length of the x- and y-coordinate integer parts is l. Therefore, an ID d ∈ K has the form d = (d_0,0...d_0,l−1.∗; d_1,0..d_1,l−1.∗) with d_0,0...d_0,l−1.∗ being the x-coordinate and

d_1,0..d_1,l−1.∗ being the y-coordinate of d. We denote the fractional part of the IDs as

.∗. However, in the following, we will only consider the integer part of coordinates as

the fractional part is only used when switching to the neighbourhood-based routing. Also, we assume keys already differ in the integer part so no keys have equal integer parts. This can easily be ensured by the central certification authority generating the keys. Consequently, the size of the key space using only the integer part is

|K| = |Kx| ∗ |Ky| with |Kx| = blx and |Ky| = bly.

The node ID d in an entry e_i,j,k of node c with ID c = (c_0,0...c_0,l−1; c_1,0...c_1,l−1) must fulfil a constraint similar to Pastry. The x-coordinate d_0,0...d_0,l−1 must match c’s x- coordinate in the first k digits. The value of digit d_0,kmust equal i. The y-coordinate

d_1,0...d_1,l−1 must also match c’s y-coordinate in the first k digits. The value of digit

d_1,k must equal j. Thus, d must be of the form d = (c_0,0...c_0,k−1i∗, c_1,0...c_1,k−1j∗) for k > 0 and d = (i∗, j∗) for k = 0.

4.2 Overlay Structure 55

Unicast Message Routing

This routing table enables prefix routing with logarithmic routing performance. Fig- ure 4.6 shows a node a sending a message to destination x. In this example, both bases are identical with b_x = 2 and b_y = 2. The ID of node a starts with 0 in the x-coordinate and 0 in the y-coordinate. Node a lies in the zone Z_0,0. A zone Z_i,j is a rectangular sub-area of the key space where all keys start with i in the x-coordinate and j in the y-coordinate. Zones can be divided into sub-zones. Zone Z_ik,jl is a sub-zone of zone Z_i,j with all keys in Z_ik,jl starting with ik in the x-coordinate and

jl in the y-coordinate.

The way the routing table is built, a has stored one node from each of the zones

Z_0,1, Z_1,0, and Z_1,1 in the top layer of its routing table. The destination x is not in

a’s zone Z_0,0 but in zone Z_1,1. Therefore, a will forward the message to the node b in Z_1,1 stored in its top routing table layer. Node b shares a common prefix with the message destination x. Both start with 1 in the x- and y-coordinate which means both are in zone Z_1,1. However, they are not in the same sub-zone. Node b’s ID starts with 10 in the x-coordinate and 11 in the y-coordinate. Thus, b is in sub-zone

Z_10,11 while the destination x is in sub-zone Z_11,11. In the second layer of its routing

table, b has stored nodes from each of the other sub-zones Z_10,10, Z_11,10, and Z_11,11. Since x is in Z_11,11, b will forward the message to c taken from the second layer of its routing table. Node c is situated in sub-zone Z_110,110 while x is in Z_111,110. Again, c has one node from each of the zones Z_110,111, Z_111,110, and Z_111,111 in the third layer of its routing table. Therefore, it will forward the message to node d in zone Z_111,110. Assuming the integer parts of IDs has three digits (the routing table has three layers), this routing process will finish here and d will continue with the neighbourhood-based routing in the Delaunay structure. It will compare its distance to x with the distances of its neighbours and find out it is the final receiver of the message.

In each routing step, the next node matches the message destination in at least one more digit in the x- and y-coordinate. Even in the above worst case, when sending node and destination share no common prefix, only l routing steps will be necessary. From l being the length of the integral part of keys and N = bl_x∗ bl_y being the size of the integral part of the key space follows l = log_bx∗byN . With even distribution

of n nodes in the integral part of the key space, the worst-case routing performance is O(log_bx∗byn).

56 Chapter 4 A Self-Stabilizing Delaunay Overlay 0 0 1 1 0 1 0 1 0 1 0 1 a x e b c d xd

Figure 4.6: Message routing using routing tables