Locally Self-Adjusting Skip Graphs

TL;DR

This paper introduces a decentralized self-adjusting skip graph algorithm that optimizes routing costs based on communication patterns, with provable bounds and efficient implementation in the CONGEST model.

Contribution

It presents the first fully decentralized, self-adjusting skip graph algorithm with theoretical bounds and a new computational model for evaluating such algorithms.

Findings

Routing cost within a constant factor of the optimal amortized cost.

Expected transformation cost is logarithmically bounded relative to the optimal.

Algorithm conforms to the CONGEST model with O(log n) message complexity.

Abstract

We present a distributed self-adjusting algorithm for skip graphs that minimizes the average routing costs between arbitrary communication pairs by performing topological adaptation to the communication pattern. Our algorithm is fully decentralized, conforms to the $\mathcal{CONGEST}$ model (i.e. uses $O(\log n)$ bit messages), and requires $O(\log n)$ bits of memory for each node, where $n$ is the total number of nodes. Upon each communication request, our algorithm first establishes communication by using the standard skip graph routing, and then locally and partially reconstructs the skip graph topology to perform topological adaptation. We propose a computational model for such algorithms, as well as a yardstick (working set property) to evaluate them. Our working set property can also be used to evaluate self-adjusting algorithms for other graph classes where multiple tree-like subgraphs overlap (e.g. hypercube networks). We derive a lower bound of the amortized routing cost for any algorithm that follows our model and serves an unknown sequence of communication requests. We show that the routing cost of our algorithm is at most a constant factor more than the amortized routing cost of any algorithm conforming to our computational model. We also show that the expected transformation cost for our algorithm is at most a logarithmic factor more than the amortized routing cost of any algorithm conforming to our computational model.

Figures

Tables

Table 1. TABLE I: Notations

Notation	Description
$m\left(x\right)$	membership vector of node x
$V_j^i$	membership vector bit of node i for level j
$T_j^i$	timestamp for node i at level j
$G_j^i$	group-id for node i at level j
$D_j^i$	is-dominating-group for node i at level j
$B_x$	group-base of node x
$l_a$	a linked list at level a
$S_t$	skip graph at time t
$M$	approximate median priority
$T_i(x,y)$	The working set number for node pair $(x,y)$ at time $i$
$WS\left(\sigma \right)$	${\sum }_{i=1}^m$ log$\left(T_i\left({\sigma }_i\right)\right)$, where $\sigma ={\sigma }_1,{\sigma }_2,\dots {\sigma }_m$
${\sigma }_i$	Communication request $(u_i,v_i)$ at time $i$
$d_{S_i}(x,y)$	Distance between nodes $x$ and $y$ in skip graph $S_i$

Equations

$$Cost(\mathcal{A},S_t,{\sigma }_t)=\frac{1}{m}\sum _{i=1}^m(d_{S_t}({\sigma }_t)+\rho (\mathcal{A},S_t,{\sigma }_t)+1)$$

$$-G_{d-1}^x\cdot t\ge M\ge -(G_{d-1}^x+1)\cdot t$$

$$V_{\alpha +1}^x=V_{\alpha +2}^x=...=V_d^x=0$$

$$d_{S_{t+1}}(x,y)\leq a\log_{3/2}\bigg{(}\frac{n^{\prime}}{2}+\frac{n^{\prime}}{2a}\bigg{)}+a=O(\log T_{t+1}(x,y))$$

$$G_{lower}=\{\begin{array}{ll}[G_0^u,G_1^u,\dots ,G_{\alpha -1}^u],& \text{if }{B}_u\le B_v\\ [G_0^v,G_1^v,\dots ,G_{\alpha -1}^v],& \text{otherwise}\end{array}$$

Full text

I Introduction

Many peer-to-peer communication topologies are designed to reduce the worst-case time per operation and do not take advantage of the skew in communication patterns. Given that most real-world communication patterns are skewed, self-adjustment is an attractive tool that can significantly reduce the average communication cost for a sequence of communications. For an unknown sequence of communications, self-adjusting algorithms minimize the average communication cost by performing topological adaptation to the communication pattern.

In the 1980s, Sleator and Tarjan published their seminal work on Splay Tree [13], which has been the inspiration of subsequent studies in self-adjusting algorithms, for example Tango BSTs [10], multi-splay trees [14], CBTree [1], dynamic skip list [9] etc. All these data structures are designed for centralized lookup operations and rely on a tree or tree-like structure. Avin et al. proposed SplayNets [6], which initiated the study of self-adjustment for distributed data structures and networks, where each communication involves a source-destination pair. However, splayNet relies on a single BST structure, and we are not aware of any study of self-adjustment for more complex data structures that relies on the interaction of multiple overlapping tree-like structures (e.g. skip graphs, hypercubic networks). This motivates our current work on self-adjustment for skip graph topologies.

A skip graph [3] $G=(V,E)$ is a distributed data structure and a well-known peer-to-peer communication topology that guarantees $O(\log n)$ worst-case communication time between arbitrary pairs of nodes, where $n=|V|$. The major advantage of skip graphs over BSTs is that skip graphs are highly resilient and capable of tolerating a large fraction of node failures. In order to achieve such resilience, skip graphs rely on interactions among $n$ overlapping skip list structures. In general, topological rearrangement of nodes of one skip list affects the structure of multiple other skip lists. Moreover, since the access pattern in unknown, an adversarial access sequence may incur the worst case communication cost for each of the communication requests. Thus it is important to keep all the skip lists balanced so that the worst case communication cost for any pair of nodes remains logarithmic. Now, self-adjusting algorithms generally attempt to move frequently communicating nodes closer to each other. However, for skip graphs, such an attempt may result in an imbalance situation and drive other uninvolved nodes away from each other, which makes it challenging to design a self-adjusting algorithm for skip graphs.

We present a self-adjusting algorithm Dynamic Skip Graphs (DSG) for skip graphs with no a priori knowledge of the future communication pattern, and analyze the performance of our algorithm. Upon each communication request, DSG first establishes communication using the the standard skip graph routing in the existing topology, and then locally and partially transforms the topology to connect communicating nodes via a direct link. Our algorithm DSG is designed for the $\mathcal{CONGEST}$ model (i.e. allowed message size per link per round is up to $O(\log n)$ bits), and requires $O(\log n)$ bits of memory for each node. We show that, for an unknown communication sequence, the routing cost for DSG is at most a constant factor more than the optimal amortized routing cost, and the expected transformation cost is at most a logarithmic factor more than the amortized cost of any algorithm conforming to our computational model.

I-A Our Contributions

We propose a computational model for self-adjusting skip graphs. Upon each communication request, our model requires any algorithm to transform the topology such that communicating nodes (the source-destination pair) get connected via a direct link. Our model also limits the memory of each node to $O(\log n)$ bits and conforms to the $\mathcal{CONGEST}$ model. 2. 2.

We propose a working set property to evaluate self-adjusting algorithms for skip graphs or similar distributed data structures. 3. 3.

We propose a self-adjusting algorithm Dynamic Skip Graphs (DSG) conforming to our model and analyze its performance. 4. 4.

Our algorithm uses a distributed and randomized approximate median finding algorithm (AMF) designed for skip graphs. We show that AMF finds an approximate median in expected $O(\log n)$ rounds.

I-B Paper organization

Section III presents our self-adjusting model for skip graphs and definitions relevant to this paper. Section II presents an overview of related work. Section IV and V present algorithm DSG and AMF, respectively. We provide a formal analysis to evaluate our algorithms in Section VI, and conclude this work in Section VII. Details on some of the steps of our algorithms are presented in the Appendix.

II Related Work

Interest in self-adjusting data structures grew out of Sleator and Tarjan’s seminal work on splay tree [13] that emphasized the importance of amortized cost and proposed a restructuring heuristics to attain the amortized time bound of $O(\log n)$ per operation. Prior to that, Allen and Munro [2], and Bitner [8] proposed two restructuring heuristics for search trees, but none were efficient in the amortized sense. In [7], Bagchi et al. presented an algorithm for efficient access in biased skip lists where non-uniform access patterns are biased according to their weights, and the weights are known. Bose et al. [9] investigated the efficiency of access in skip lists when the access pattern is unknown, and developed a deterministic self-adjusting skip list whose running time matches the working set bound, thereby achieving dynamic optimality. Afek et al. [1] presented a version of self-adjusting search trees, called CBTree, that promote a high degree of concurrency by reducing the frequency of “ tree rotation.” Avin et al. [6] presented SplayNet, a generalization of Splay tree, where, unlike the splay trees, communication is allowed between any pair of nodes in the tree. In [5], Avin, et al. extended the concept of splay trees to P2P overlay networks of multiple binary search trees (OBST). However, their work addresses a routing variant of the classical splay trees that focuses on the lookup operation only. In [4], Avin et al. presented a greedy policy for self-adjusting grid networks that locally minimizes an objective function by switching positions between neighboring nodes. $\textsf{SKIP}^{+}$ [12] presented a self-stabilization (not self-adjusting) algorithm for skip graphs. [11] presents some of the early ideas of our work.

III The Model and Definition

We begin with a quick introduction of Skip Graphs [3]. A Skip Graph consists of nodes positioned in the ascending order of their identifiers (often called keys) in multiple levels. Level 0 consists of a doubly linked list containing all the nodes. The linked list at level 0 is split into 2 distinct doubly linked lists at level 1. Similarly, each of the linked lists at level 1 is split into 2 distinct linked lists at level 2, and this continues recursively for upper levels until all nodes become singleton. In other words, every linked list with at least 2 nodes at any level $i$ is split into 2 distinct linked lists at level $i+1$. The number of levels in a skip graph is called the height of the skip graph. When a linked list splits into 2 linked list at the next upper level, we denote the split linked lists as 0-sublist (or 0-subgraph) and 1-sublist (or 1-subgraph). Note that we refer the base (lowest) level as level 0. We denote the height of a skip graph as $H$.

For simpler representation, we map a skip graph into a binary tree of linked lists. To this end, the linked list at level 0 is represented by the root node of the tree, and the 0-sublist and the 1-sublist at level 1 are represented by the left child and right child of the root, respectively. Similarly, every linked list of the skip graph is represented by a node in the binary tree, mimicking the parent child relationship of the skip graph in that of its equivalent binary tree. Figure 1(a) shows a skip graph with 3 levels, and figure 1(b) shows the corresponding binary tree representation.

Each node $x$ in a skip graph has a membership vector $m(x)$ of size $H-1$. The $i^{th}$ bit of $m(x)$ represents the sublist (0 or 1) that contains node $x$ at level $i$. For example, the membership vector of node $M$ in figure 1(b) is 01, as $M$ belongs to the 0-sublist at level 1, and 1-sublist at level 2.

Every node in the binary tree is the root of a subtree that represents a sub(skip)graph (or sub graph) of the skip graph. We refer the subgraph rooted by a 0-sublist and 1-sublist as 0-subgraph and 1-subgraph, respectively. Since the construction is recursive, we can also designate a subgraph as $b$-subgraph, where $b$ is a bit string containing the common prefix bits of the membership vectors for all nodes in the subgraph. For example, the subgraph containing nodes $G$ and $W$ in figure 1(b) is designated by $10$-subgraph.

Let $V=\{1,...,n\}$ be a set of nodes (or peers). Let $\mathcal{S}$ be the family of all Skip Graphs of $n$ nodes, where each topology $G(V,E)\in\mathcal{S}$ is a skip graph with $O(\log n)$ levels. For any skip graph $S\in\mathcal{S}$, $L_{i}$ denotes the set of all linked lists at level $i$ of $S$. We define the following balance property that must hold for the family of skip graphs $\mathcal{S}$:

Definition (a-balance Property). A Skip Graph satisfies the $a$-balance property if there exists a positive integer $a$, such that among any $a+1$ consecutive nodes in any linked list $l\in L_{i}$, at most $a$ nodes can be in a single linked list in $L_{i+1}$. The $a$-balance property ensures that the length of the search path between any pair of nodes is at most $a\cdot\log n$.

Self-Adjusting model for Skip Graphs. We consider a synchronous computation model, where communications occure in rounds. A node can send and receive at most 1 message through a link in a round (i.e. $\mathcal{CONGEST}$ model). Our model limits the memory of each node to $O(\log n)$ bits. Given a skip graph $S\in\mathcal{S}$, and a pair of communicating nodes $(u,v)\in V\times V$, a self-adjusting algorithm performs the followings:

Establishes communication between nodes $u$ and $v$ in $S$. 2. 2.

Transforms the skip graph $S$ to another skip graph $S^{\prime}\in\mathcal{S}$, such that nodes $u$ and $v$ move to a linked list of size two at any level in $S^{\prime}$. This implies that a direct link needs to be established between nodes $u$ and $v$.

Note that the height of $S^{\prime}$ must be $O(\log n)$ since $S^{\prime}\in\mathcal{S}$. Let $\sigma=(\sigma_{1},\sigma_{2},...,\sigma_{m})$ be an unknown access sequence consisting of $m$ sequential communication requests, $\sigma_{t}=(u,v)\in V\times V$ denotes a routing request from source $u$ to destination $v$. Given a skip graph $S$, we define the distance $d_{S}(\sigma_{t})$ as the number of intermediate nodes in the communication path from the source to destination associated with request $\sigma_{t}$, where the communication path is obtained by standard skip graph routing algorithm [3]. An overview of the standard skip graph routing is presented in Appendix A-B.

Given a request $\sigma_{t}$ at time $t$, let an algorithm $\mathcal{A}$ transforms the current skip graph $S_{t}\in\mathcal{S}$ to $S_{t+1}\in\mathcal{S}$. We define the cost for network transformation as the number of rounds needed to transform the topology. We denote this transformation cost at time $t$ as $\rho(\mathcal{A},S_{t},\sigma_{t})$. Similar to a prior work [6], we define the cost of serving request $\sigma_{t}$ as the distance from source to destination plus the cost of transformation performed by $\mathcal{A}$ plus one, i.e., $d_{S_{t}}(\sigma_{t})+\rho(\mathcal{A},S_{t},\sigma_{t})+1$.

Definition (Average and Amortized Cost). We used definitions similar to [6] here. Given an initial skip graph $S_{0}$, the average cost for algorithm $\mathcal{A}$ to serve a sequence of communication requests $\sigma=(\sigma_{1},\sigma_{2},\cdots,\sigma_{m})$ is:

[TABLE]

The amortized cost of $\mathcal{A}$ is defined as the worst possible cost to serve a communication sequence $\sigma$, i.e.

$max_{S_{0},\sigma}$ Cost$(\mathcal{A},S_{0},\sigma)$.

Definition (Sub Skip Graph). A sub skip graph (often called subgraph in this paper) is a skip graph that is a part of another skip graph. In other words, given a skip graph $S(V,E)$, a sub skip graph $S^{\prime}(V^{\prime},E^{\prime})$ is a skip graph in $S$ such that $V^{\prime}\subseteq V$ and $E^{\prime}$ is the set of links from $S$ induced by the nodes in $V^{\prime}$. We call a sub skip graph is at level $d$ when all nodes in the sub skip graph share a common membership vector prefix of size $d$. We call the lowest level of a sub skip graph as the base level, and the linked list that contains the nodes of a sub skip graph as the base linked list for that sub skip graph. Observe that there exists a sub skip graph for all linked lists in any skip graph.

Definition (Working Set Number). We denote the working set number for request $\sigma_{i}$ as $T_{i}(\sigma_{i})$. Let $u_{i}$ be the source and $v_{i}$ be the destination specified by communication request $\sigma_{i}$. To define $T_{i}(\sigma_{i})$, we construct a communication graph $G$ with the nodes that communicated (either as source or destination) during the time period starting from the last time $u_{i}$ and $v_{i}$ communicated, and ending at time $i$. We draw an edge between any two nodes in $G$ if they communicated in this time duration. Now, we define the working set number for request $\sigma_{i}$, $T_{i}(\sigma_{i})$, as the number of distinct nodes in $G$ that have a path from either $u_{i}$ or $v_{i}$. In case $u_{i}$ and $v_{i}$ are communicating for the first time, $T_{i}(\sigma_{i})=n$ by default, where $n$ is the number of nodes in the skip graph.

As an example, for the latest communication request $(u,v)$ shown in figure 2(a), the corresponding communication graph $G$ is shown in figure 2(b). The number of distinct nodes in $G$ that have a path from either $u$ or $v$ is 5; therefore the working set number for the communication request is 5.

Definition (Working Set Property). For a skip graph $S$ at time $i$, the working set property for any node pair $(x,y)\in S$ holds iff $d_{S}(x,y)\leq\log T_{i}(x,y)$. Note that, the $\log$ in the definition is to address the tree-like structure of the skip graph topology.

Definition (Working Set Bound). We define the working set bound as $WS(\sigma)=\sum_{i=1}^{m}$ log$(T_{i}(\sigma_{i}))$.

Theorem 1**.**

For an unknown communication sequence $\sigma=\sigma_{1},\sigma_{2},\dots,\sigma_{m}$, the amortized routing cost for any self-adjusting algorithm conforming to our model is at least $WS(\sigma)$ rounds.

Proof.

Let us assume that the theorem does not hold. Then there must be at least one request $\sigma_{i}=(u_{i},v_{i})$ such that $d_{S_{i}}(u_{i},v_{i})<T_{i}(u_{i},v_{i})$. However, due to the construction of the skip graph, this results in existance of a node $w_{i}$ such that $d_{S_{i}}(u_{i},w_{i})>T_{i}(u_{i},w_{i})$. An example to illustrate this idea is presented right after this proof.

Since the communication sequence is unknown, it is possible that $(u_{i},w_{i})$ is chosen as request $\sigma_{i}$ instead of $(u_{i},v_{i})$. Since this argument is applicable for any $\sigma_{i}\in\sigma$, the theorem holds. ∎

Example of Working Set Bound. Consider the communication graph in Figure 3. Let $l$ be a linked list of size $2k$ in a skip graph. Let nodes $U,V,A,A_{1},A_{2},\cdots,A_{n-2}$ belong to the linked list $l$. Let the linked list $l$ split into 2 subgraphs (i.e. sublists) each with size $k$ at the next (upper) level. Suppose node $A$ moves to the 0-subgraph. Now, we need to choose other $k-1$ nodes to accompany node $A$ in the 0-subgraph.

Let we move nodes $U$ and $V$ to the 0-subgraph. Then there exists a node $A_{i},1\leq i\leq k-2$ that moves to the 1-subgraph. Clearly this violates the working set property for the pair $(A,A_{i})$. However, if we move nodes $U$ and $V$ to the 1-subgraph, we violate the working set property for the pair $(A,U)$. Thus, $U$ must move to the 0-subgraph and $V$ must move to the 1-subgraph. Note that, at time $t^{\prime}+k$, the working set number for pair $(U,V)$, $T_{t^{\prime}+k}(U,V)=k+1$; and the routing distance for pair $(U,V)$ is $\left\lceil{T_{t^{\prime}+k}(U,V)}\right\rceil=\left\lceil{\log(k+1)}\right\rceil=\log_{2}(2k)$.

IV Dynamic Skip Graphs (DSG)

IV-A Overview

Upon a communication request, our algorithm DSG first establishes the communication using the standard skip graph routing, then performs atomic topological transformation conforming to the self-adjusting model. The key idea behind DSG is that frequently communicating nodes form groups at different levels and a node’s attachment to a group is determined by a timestamp. Each node has a group-id and a timestamp associated with each level. A node is a member of a group at each level, and the group-id is an identifier that represents a group. All nodes belong to the same group at a level hold the common group-id. The timestamp associated with a level is used by DSG to identify how attached a node is with its group at that level.

When two nodes from two different groups communicate, DSG merges the communicating groups to a single group. However, when a group grows too big to be accommodated in a single linked list at the corresponding level (due to the structural constraint of the skip graph), DSG splits the group into two smaller groups. There are three challenges here. First, since the goal of DSG is to ensure that the working set property always holds for any node pair in any group, distance between any two nodes from any non-communicating group should not increase. In other worlds, routing distances among nodes of any non-communicating groups should not be affected due to a transformation. Second, the working set property must hold for any node pair in the merged and split groups after a transformation. Third, a transformation requires a partial reconstruction of the skip graph structure. According to our self-adjusting model, the height of the skip graph must remain $O(\log n)$ after any reconstruction.

Transformation starts from the highest level at which communicating nodes share a common linked list. For example, the highest level with a common linked list for nodes $A$ and $M$ in the skip graph in Figure 1 is level 1 and the common linked list is the linked list that contains only nodes $A$, $J$ and $M$. Starting from the highest level with common linked list, transformation continues recursively and parallelly in the upper levels until all the involved nodes become singleton (i.e. move to a linked list of size 1). For each of the newly created linked lists of size $>1$, transformation takes place as follows:

1. –

Each node of the linked list computes a priority using certain priority rules. Each priority is a function of node’s group-id and timestamp for the corresponding level. The priorities are computed in a way such that all groups have a distinct range of priorities. The communicating nodes have the highest priority, each node of the merged group has a positive priority, and all other nodes have a negative priority. 2. –

All nodes of the linked list compute an approximate median priority using the algorithm AMF. In general, at the next upper level after transformation, any node with a priority higher or equal to the approximate median priority moves to the 0-subgraph, and any node with a priority lower than the approximate median priority moves to the 1-subgraph. DSG uses priorities to ensure that nodes from the same group remain together after a transformation. However, a transformation technique based on comparing priority with approximate median priority may split a non-communicating group. Such cases are handled carefully by DSG. Note that, the approximate median priority is used to ensure that the sizes of the 0-subgraph and 1-subgraph are roughly the same after a transformation, keeping the height of the skip graph always $O(\log n)$.

Since communicating nodes always move to the 0-subgraph, after transformation in all levels, communicating nodes are guaranteed to move to a linked list of size 2. Each node involved in the transformation reassigns its group-ids and timestamps such that DSG can work consistently for future communication requests.

IV-B Setup and notations

Let $H_{t}$ be the height of the skip graph at time $t$. DSG requires every node to hold $H_{t}$ bits to store its membership vector. In addition, each node stores a timestamp and a group-id for each of the levels. For node $i$ and level $j$, we use the notations $V^{i}_{j}$, $T^{i}_{j}$ and $G^{i}_{j}$ to denote the stored membership vector bit, timestamp, and group-id respectively. Initially, all timestamps are set to zero and all group-ids are set to the corresponding node’s identifier.

Figure 4(a) shows a communication graph $G$, where each edge is labeled with the time associated with the most recent communication. Observe that nodes $U$ and $V$ communicate at time 8 as shown in $G$. For the communication graph $G$, Figure 4(b) shows a binary tree representation of a valid skip graph ($S_{8}\in\mathcal{S}$) at time 8 obtained by DSG. Figure 4(c) shows a valid skip graph ($S_{9}\in\mathcal{S}$) representation, where $S_{9}$ is transformed from $S_{8}$ using DSG, as a result of the communication between nodes $U$ and $V$ at time 8. The numbers below each node in Figure 4(b) and (c) give the timastamp of the node at the corresponding level. We use this transformation from $S_{8}$ to $S_{9}$ as an example for the description of our algorithm for the remaining paper.

For a communication request from node $u$ to node $v$, let $\alpha$ be the highest common level of the current skip graph with a linked list containing both nodes $u$ and $v$. Let $l_{\alpha}$ denote that linked list, then $u,v\in l_{\alpha}$. Let $t$ be the time when the request is originated, and $S_{t}$ be the skip graph at time $t$. In Figure 4(b), for nodes $U$ and $V$, $\alpha=0$, $l_{\alpha}$ is the linked list represented by the root of the binary tree, and $t=8$.

We explain different parts of our algorithm in detail in following subsections.

IV-C Transformation from $S_{t}$ to $S_{t+1}$

Upon a routing from node $u$ to node $v$, node $v$ records the highest common level number $\alpha$ and shares $\alpha$ with node $u$. Then both nodes $u$ and $v$ broadcast a transformation notification to all nodes in $l_{\alpha}$. The notification message includes all $H_{t}$ timestamps, group-ids and membership vectors of nodes $u$ and $v$. All nodes $x\in l_{\alpha}$ compute a priority $P(x)$ by using following priority-rules:

1. P1:

(Rule for communicating nodes). Nodes $u$ and $v$ set $\infty$ as their priority. In other words, set $P(u)=P(v)=\infty$. 2. P2:

(Rule for nodes in the same group of either communicating nodes at level $\alpha$). All nodes $x\in l_{\alpha},x\neq u,x\neq v,G^{x}_{\alpha}=G^{u}_{\alpha}$ assign their priority $P(x)=\min(T^{x}_{c},T^{u}_{c})$ where $c$ is the highest level in $S_{t}$ such that $G^{x}_{c}=G^{u}_{c}$. Similarly, all nodes $x\in l_{\alpha},x\neq u,x\neq v,G^{x}_{\alpha}=G^{v}_{\alpha}$ assign $P(x)=\min(T^{x}_{c},T^{v}_{c})$ where $c$ is the highest level in $S_{t}$ such that $G^{x}_{c}=G^{v}_{c}$. 3. P3:

(Rule for other nodes). Each node $x\in l_{\alpha},x\neq u,x\neq v,G^{x}_{\alpha}\neq G^{u}_{\alpha},G^{x}_{\alpha}\neq G^{v}_{\alpha}$ (i.e. neither in $u$’s nor in $v$’s group at level $\alpha$) set $P(x)=-(G^{x}_{\alpha}\cdot t)+T^{x}_{\alpha+1}$.

We require that group identifiers are non-negative integers (possibly an ip address of a node). Observe that, all nodes of the communicating group at level $\alpha$ have a positive priority as a timestamp is always positive, and rest of the nodes have a negative priority as DSG ensures that $t>T^{x}_{\alpha+1}$. Also, according to P3, priorities assigned to nodes from a non-communicating group range between $-(G^{x}_{\alpha}\cdot t)$ and $-(G^{x}_{\alpha}+1)\cdot t$, where $G^{x}_{\alpha}$ is the group-id.

In our example in Figure 4, as nodes U and V communicate at time 8, the $\alpha$ is 0 ($S_{8}$ in Figure 4(b)). Let us assume that the nodes’ numerical identifiers are determined by their positions in the English alphabet, e.g. identifier for node A is 1, identifier for node B is 2, and so on. According to the priority rule P1, $P(U)=P(V)=\infty$; and according to the priority rule P2, $P(D)=2$, $P(G)=2$, $P(B)=2$ and $P(E)=5$. Let us assume that the group-ids $G^{H}_{0}=G^{J}_{0}=10$ (as H is the tenth letter in alphabet) and $G^{F}_{0}=G^{I}_{0}=6$. Hence, according to the priority rule P3, $P(H)=P(J)=-(10\times 7)+2=-68$, and $P(F)=P(I)=-(6\times 7)+2=-40$.

At this point, node $u$’s group at level $\alpha$ merges with node $v$’s group at the same level by updating their group-ids. To this end, all nodes $x\in l_{\alpha}$ with $G^{x}_{\alpha}=G^{u}_{\alpha}$ or $G^{x}_{\alpha}=G^{v}_{\alpha}$ set $G^{x}_{\alpha}=u$. Note that, by $u$, we mean the identifier of node $u$.

Transformation begins at level $\alpha+1$ and recursively continues at upper levels. Only the nodes in linked list $l_{\alpha}$ take part in the transformation. For the remaining section, we write $d$ to refer the current level of transformation and $l_{d-1}$ to refer the linked list that is involved in the transformation. Initially $d=\alpha+1$ and $l_{d-1}=l_{\alpha}$.

All nodes in $l_{d-1}$ find an approximate median priority to decide whether to move to the 0-subgraph or to the 1-subgraph (i.e. determine new membership vector bit $V^{x}_{d}$ in the new skip graph $S_{t+1}$). We propose a distributed approximate median finding algorithm (AMF) for skip graphs to find the approximate median in expected $O(\log_{a}n)$ rounds, where $a$ is a constant. The algorithm AMF is described in section V. For now let us consider AMF as a black box that finds an approximate median priority and broadcasts it to all nodes in linked list $l_{d-1}$.

However, to utilize AMF, in some cases we require to identify the nodes that moved to the 0-subgraph by receiving a positive approximate median priority. To this end, we introduce a set of boolean variables referred to as is-dominating-groups, held by each node of the skip graph. Each node holds $H_{t}$ is-dominating-group variables, one for each level. Let $D^{x}_{d}$ denote the is-dominating-group of node $x$ for level $d$. The goal is to ensure that any node $x$ with $D^{x}_{d}=True$ moved to the 0-subgraph at level $d+1$ in past when it received a positive approximate median priority at level $d$ for the last time.

Let the approximate median priority be $M$. One of the following cases must follow:

Case 1 ($M$ is positive). Each node $x$ with $P(x)\geq M$ moves to the 0-subgraph at level $d$ and sets is-dominating-group $D^{x}_{d}=True$. Each node $x$ with $P(x)<M$ moves to the 1-subgraph at level $d$ and sets is-dominating-group $D^{x}_{d}=False$. According to the priority rules P1 and P2, this case splits the merged group of nodes $u$ and $v$.

Case 2 ($M$ is Negative). When $M$ is negative, there may exist a group $g_{s}$ such that all nodes $x\in g_{s}$ finds the following condition true.

[TABLE]

If that happens, splitting group by comparing $P(x)$ and $M$ (as we do for case 1) may split the group $g_{s}$ at level $d$ as its nodes may move to different subgraphs. Given that $M$ is negative, the priority rule P3 confirms that group $g_{s}$ is a non-communicating group at level $d$ (i.e. contains neither $u$ nor $v$). Clearly the working set property will be violated if the group $g_{s}$ is split at level $d$ since it will increase the distance between some node pairs in group $g_{s}$. To fix this issue, nodes in $l_{d}$ perform a distributed count to compute $|l_{d}|$ and $|g_{s}|$. Then nodes decide which subgraph to move to as follows:

• –

If $|g_{s}|>\frac{2}{3}|l_{d}|$ ($|g_{s}|$ is too big, thus we need to split $g_{s}$)

• –

any node $x\in g_{s}$ moves to the 1-subgraph if $D^{x}_{d}=True$; $x$ moves to the 0-subgraph otherwise.

• –

any node $x\in l_{d-1}\text{ and }x\not\in g_{s}$ moves to the 0-subgraph.

• –

If $|g_{s}|<\frac{1}{3}|l_{d}|$ ($|g_{s}|$ is sufficiently small, thus we move all nodes of $g_{s}$ either to the 0-subgraph or to the 1-subgraph)

• –

any node $x$ such that $x\in l_{d-1}\text{ and }x\not\in g_{s}$ moves to the 0-subgraph if $P(x)\geq M$; $x$ moves to the 1-subgraph otherwise.

• –

Let $L_{low}=\{x\in l_{d}|P(x)<M\}$ and $L_{high}=\{x\in l_{d}|P(x)\geq M\}$. Clearly, $|l_{d}|=L_{low}+L_{high}$. Any node $x\in g_{s}$ moves to the 0-subgraph if $L_{high}<L_{low}$; $x$ moves to the 1-subgraph otherwise.

• –

If $\frac{1}{3}|l_{d}|\leq|g_{s}|\leq\frac{2}{3}|l_{d}|$ (Move all nodes of $g_{s}$ to the 1-subgraph and rest of the nodes to the 0-subgraph)

• –

any node $x$ such that $x\in l_{d-1}\text{ and }x\not\in g_{s}$ moves to the 0-subgraph.

• –

any node $x\in g_{s}$ moves to the 1-subgraph.

Note that $|g_{s}|$, $L_{low}$ and $L_{high}$ can be computed in $O(\log n)$ rounds by computing distributed sum using a balanced skip list. Algorithm AMF constructs a balanced skip list to compute the median priority. The balanced skip list created by AMF can be reused to compute $|g_{s}|$, $L_{low}$ and $L_{high}$. To avoid distraction, we present the distributed sum algorithm in Appendix A-D.

As nodes decide which subgraph to move to, two new linked lists are formed at level $d$. To find the left and right neighbors at level $d$, nodes linearly search for neighbors at level $d-1$. Because of the a-balance property, it is guaranteed that a node finds both of its left and right neighbors in at most $a$ rounds (end-nodes have just one neighbor). All nodes $x$ in the new linked lists that do not contain communicating nodes $u$ and $v$ recompute $P(x)$ (for upcoming transformation at level $d$) using the priority rule P4. Computation of $P(x)$ with P4 is similar to P3 except that $\alpha$ is replaced by $d$.

1. P4:

(Rule for nodes moved to a linked list that does not contain nodes $u$ and $v$). Each node $x$ moves to a linked list $l_{d}$ such that $u,v\neq l_{d-1}$ sets $P(x)=-(G^{x}_{d}\cdot t)+T^{x}_{d+1}$.

Since the communicating nodes $u$ and $v$ always move to the 0-subgraph, a linked list $l_{d}$ contains nodes $u$ and $v$ only if the following condition is true for all nodes $x\in l_{d}$.

[TABLE]

The transformation procedure described above is performed recursively and parallelly by each new linked list until all nodes become members of a singleton list. Clearly this ensures that node $u$ and $v$ get connected directly, and all nodes $x\in l_{\alpha}$ finds their new and complete membership vectors.

Getting back to our example in Figure 4, let the approximate median priority $M$ be 2 for $d=1$. Then nodes U, V, E, B, G and D move to the 0-subgraph and nodes F, I, H and J move to the 1-subgraph at level 1. Now nodes in the 1-subgraph recomputes their priority by using P4. Then both linked lists at level 1 performs the transformation recursively and paralelly, and this continues at upper levels.

In the following two subsections, we discuss how nodes involved with a communication reassigns their group-ids and timestamps.

IV-D Assignment of new group-ids

For each level $d=\alpha,\alpha+1,\cdots,H_{t+1}$, each node $x\in l_{d-1}$ checks if nodes $u$ and $v$ belong to their own linked list at level $d$ by checking the condition in equation 3. If a node finds the condition in equation 3 to be true, the node sets its group-id $G^{x}_{d}$ to the identifier of node $u$. If the condition in equation 3 is found to be false by any node, it checks if its group at level $d$ is getting split due to the transformation. A group without communicating nodes $u$ and $v$ can split at level $d$ only if the group is $g_{s}$ and $|g_{s}|>\frac{2}{3}|l_{d}|$. In case of such a split, the identifier of the left-most node in the split group is used as the new group-id. Observe that it is easy for the left-most node to detect itself since it does not find a left neighbor. The balanced skip list structure created by algorithm AMF is then reused to propagate the new group-id to all the nodes of the group. The left-most node first sends its identifier to the head node of the balanced skip list, and then the identifier is broadcasted to all nodes at the base level of the skip list. The balanced skip list is destroyed once the new group-id is sent to all members of the group.

As nodes $u$ and $v$ move to the same group, for correctness, it is necessary that all nodes in node $u$’s and node $v$’s group at any level $d<\alpha$ in $S_{t}$ must have the same group-id at level $d$ in $S_{t+1}$. All such nodes update their group-ids for levels below $\alpha$ by using the procedure presented in Appendix A-C, only if $G^{u}_{\alpha-1}\neq G^{v}_{\alpha-1}$.

IV-E Assignment of new timestamps

Each node $x\in l_{\alpha}$ updates its timestamps by using the following timestamp-rules (executes in the order given below):

1. T1:

Let $d^{\prime}$ be the level at which nodes $u$ and $v$ form a linked list of size 2. Nodes $u$ and $v$ set $T^{u}_{d^{\prime}}=T^{u}_{d^{\prime}+1}=t$ and $T^{v}_{d^{\prime}}=T^{v}_{d^{\prime}+1}=t$. Note that both nodes $u$ and $v$ become singleton in level $d^{\prime}+1$. Nodes $u$ and $v$ also set $T^{u}_{i}=T^{v}_{i}=max(T^{u}_{i},T^{v}_{i})$ for $i=d^{\prime}-1,d^{\prime}-2,\cdots,B_{u}$. For an example, check the timestamps of nodes $U$ and $V$ in $S_{9}$ (Figure 4(c)). 2. T2:

For a node $x$, let $c^{\prime}$ be the size of the longest common postfix between membership vectors $m(u^{\prime})$ and $m(x)$ in $S_{t}$, where $u^{\prime}$ is the nearest communicating node (either $u$ or $v$) to $x$ in $S_{t}$. For example, in $S_{8}$ (Figure 4(b)), $c^{\prime}$s for nodes $E$ and $G$ are 2 and 1, respectively. Let $M^{x}_{d}$ be the approximate median priority received by node $x$ at level $d$. For each level $d>\alpha$, each node $x$ with $G^{x}_{d}=G^{u}_{d}$ in $S_{t+1}$ (i.e. after group reassignment) sets $T^{x}_{d+1}=T^{x}_{c}$, where $c$ is the lowest level in $S_{t}$ with $\alpha\leq c<c^{\prime}$ such that $T^{x}_{c}>M^{x}_{d}$. If no such $T^{x}_{c}$ exists, node $x$ sets $T^{x}_{d+1}=M^{x}_{d}$. For an example, check the timestamps of node $E$ in $S_{t+1}$ (Figure 4(c)) at levels 1 and 2, assuming $M^{E}_{0}=2$ and $M^{E}_{1}=5$. 3. T3:

Let $x$ be a node such that $x\neq u,x\neq v,x\in l_{\alpha}$ with $G^{x}_{\alpha}=G^{u}_{\alpha}$ in $S_{t}$ (before transformation). Let $c^{\prime}$ be the size of the longest common postfix between $m(u)$ and $m(x)$ in $S_{t}$ and $c^{\prime\prime}$ be the longest common postfix between $m(u)$ and $m(x)$ in $S_{t+1}$. If $c^{\prime}-1>c^{\prime\prime}+1$, each node $x$ sets $T^{x}_{i}=T^{x}_{c^{\prime}}$ for all $i=c^{\prime}-1,c^{\prime}-2,\cdots,c^{\prime\prime}+1$. Similarly, each $x$, $x\neq u,x\neq v,x\in l_{\alpha}$ with $G^{x}_{\alpha}=G^{v}_{\alpha}$ at time $t$ (before transformation), updates their timestamps w.r.t. node $v$. For example, for node $E$ in Figure 4, $c^{\prime}=3$ and $c^{\prime\prime}=2$. Hence T3 does not apply for node $E$. 4. T4:

Each node $x$ that initialized or received $G_{lower}$ finds the lowest level $d$ such that $T^{x}_{d+1}=0$. If such a $d$ exists and if $d>B_{x}$, node $x$ sets $T^{x}_{i}=T^{x}_{d+1}$ for $i=d,d-1,\cdots,B_{y}$. 5. T5:

Let $x$ be a node, $x\in l_{\alpha}$ and $x$ belongs to a group $g$ at level $d$ in $S_{t}$, $d\geq\alpha$, such that $g$ splits into two subgroups at level $d$ in $S_{t+1}$. Each node $x$ sets $T^{x}_{d-1}=T^{x}_{d}$ only if $T^{x}_{d-1}=0$. 6. T6:

A group-base of a node is the highest level at which the node belongs to its biggest group. For example, in the skip graph $S_{8}$ in Figure 4(b), the group-base for node B is 1, as 1 is the highest level at which node $B$ is a member of its biggest group (B,G,D,U). Appendix A-C presents details about how nodes maintain their group-base in a distributed manner. Let $B_{x}$ denote the group-base of a node $x$. Each node $x\in l_{\alpha}$ sets $T^{x}_{d}=0$ for all $d<B_{x}$. For an example, check the timestamps of nodes $F$ and $I$ in $S_{t+1}$ (Figure 4(c)) at level 1 and 0. Note that, $B_{F}=B_{I}=2$ in $S_{t+1}$.

After reassigning the timestamps, all nodes $x\in l_{\alpha}$ independently set themselves free for the next communication or transformation. A summary of the algorithm DSG is presented in Algorithm 1.

IV-F Maintaining the a-balance property

When a node $x$ moves to a new subgraph at level $d$, node $x$ checks if the a-balance property is being violated at level $d$ by the rearrangement of nodes. The balanced skip list created by AMF is reused to check if any consecutive $a$ nodes at level $d-1$ have moved to the same subgraph at level $d$. All nodes in the skip list at level $d$ check the new membership vector bit of $a$ nearby nodes at level $d-1$ in both sides and share this information with both neighbors of the skip list at level $d$ to detect chains. If a chain of size $a$ or longer is detected, a dummy node is placed in the sibling subgraph at level $d$ to break the chain.

A dummy node is a logical node which requires $O(\log n)$ links and an identifier. A dummy node does not hold any data and only used for routing purpose. To implement dummy nodes, all regular nodes need to have the ability to handle extra $O(\log n)$ links.

When a dummy node is placed to break a chain, the identifier is picked by checking the identifier of a neighbor of the dummy node at level $d$ to ensure that all identifiers remain sorted at the base level of $S_{t+1}$. A dummy node does not participate in transformation and destroys itself when a transformation notification is received. While being destroyed, a dummy node simply links its left and right neighbors at all levels and deletes itself. The sole purpose of dummy nodes is to ensure that a-balance property is preserved after a transformation. Note that, the maximum number of dummy nodes possible is $n/a$.

IV-G Node addition/removal

Nodes can be added or removed by using standard node addition or removal procedures for skip graphs. When a node is added, the new node needs to initialize its variables with the default (initial) values. Following a node addition, the new node checks if the a-balance property is violated due to the node addition. Following a node deletion. a neighbor of the deleted node from each level checks if the a-balance property is violated due to node deletion. In case of a violation, a dummy node is placed to protect the a-balance property, as described in Section IV-F.

V Approximate Median Finding for Skip Graphs (AMF)

Given a linked list of size $n$ with each node holding a value, AMF is a distributed algorithm that finds an approximate median of the values in expected $O(\log n)$ rounds. Given that the size of the linked list is bigger than a constant $a$, we first construct a probabilistic skip list where the left-most node steps up to the next level with probability 1, and all other nodes step up to the next level with a probability $1/a$. After stepping up to the next level, nodes find their neighbors linearly from the level it stepped up. We write two consecutive nodes are supported by $k$ nodes if they have $k-1$ nodes in between at the immediate lower level. When a linked list at some level is built, nodes locally check if two consecutive nodes are supported by at least $a/2$ and at most $2a$ nodes. If two or more consecutive nodes are supported by less than $a/2$ nodes, they select the node with the highest identifier as a leader, and leader asks some nodes to step down to make sure each consecutive nodes in the list is supported by at least $a/2$ modes. Similarly, if two consecutive nodes are supported by more than $2a$ nodes, the node with the higher identifier asks some nodes in between to step up so that no two consecutive nodes in the list are supported by more than $2a$ nodes. The construction ends when the left-most node become the member of a singleton list (i.e. the root of the skip list) at some level. Let $l_{i}$ denote the linked list at level $i$ of the skip list. We refer the base level as level 0. Let $h$ be the height of the skip list, then level $h$ is the only level where the left-most node is singleton. The left-most node (i.e. root) broadcasts the value $h$ to all nodes of the skip list. Let $h=\log_{b}n$, then $2a\geq b\geq a/2$.

Median finding algorithm is a recursive algorithm that works in rounds. At the first round each node $x\in l_{0}$, $x\notin l_{1}$ forwards their values to their left neighbors, and any value received from the right neighbor is also forwarded to the left neighbor. This way values hold by all nodes that did not step up to level 1 are gathered to their nearest left neighbor that stepped up to level 1 (nodes in $l_{1}$). For implementation, while forwarding the value to the left neighbor, a node adds a “last-node” tag with its value if it has an immediate right neighbor that has lifted to the upper level. When a node in linked list $l_{1}$ receives such tag, it can move to the next step knowing that it will not receive any more value from level 0.

Each node $x\in l_{1}$ is expected to have $a$ values including its own. All nodes $x\in l_{1}$ but $x\notin l_{2}$ forward all values they have to the nearest left neighbor that stepped up at level 2. Therefore, all nodes $x\in l_{3}$ are expected to have $a^{2}$ values. This process continues until nodes at level $\left\lceil\log_{a/2}h\right\rceil+2$ (note that $\log_{a/2}h=\log_{a/2}\log_{b}n)$ receives all their values. Clearly each node $x\in l_{\left\lceil\log_{a/2}h\right\rceil+2}$ must receive at least $(a/2)^{(\left\lceil\log_{a/2}h\right\rceil+2)}=\frac{a^{2}h}{4}$ values.

These values are sorted locally by the nodes $x\in l_{\left\lceil\log_{a/2}h\right\rceil+2}$, and each node uniformly samples $ah$ values from the sorted list. Nodes keep only the sampled values for the next round and discard all other values they have. Nodes that did not step up to any further level forward their sampled values to the nearest left-neighbor that stepped up to the next level. A similar tagging mechanism explained earlier can be used for the implementation purpose. It is important to note that this algorithm satisfies the $\mathcal{CONGEST}$ model since all messages are $O(\log n)$ in size. The process of gathering values in the nearest left neighbor at upper level and sampling them continues recursively until the left-most node of the skip list receives all the (expected $a^{2}h$) values at level $h$ (the top level).

Each value forwarded by any node is attached with a left rank and a right rank. The left (right) rank attached with a value is the number of nodes in $l_{\alpha}$ that are guaranteed to have a larger (smaller) value than the value. Before every sampling, each node computes their left rank and right rank. Initially (at the base level) each node at the base level set both the left and right ranks attached with their value to zero. When a list of values are locally sorted by any node, the node computes the new left and right ranks for all the sampled values. The new left rank of a value is computed by adding the left ranks attached with all larger values in the sorted list. Similarly the new right rank of a value is computed by adding all the attached right ranks attached with the smaller values in the sorted list. Nodes forward their sampled values with the computed left and right ranks to the nearest left neighbor at the current level of the skip list.

When the left-most node at the top level of the skip list receives values from level $h-1$ (the second highest level), it computes the median based on the left and right rank attached with the values and then broadcasts the value to all nodes in $l_{0}$ as the approximate median.

The algorithm AMF is summarized in Algorithm 2.

Lemma 1**.**

Given a linked list of $n$ nodes (each with a value), the algorithm AMF outputs a value within the range of ranks $\frac{n}{2}\pm\frac{n}{2a}$.

Proof.

Let $m$ be the actual median value, and $m_{l}$ and $m_{r}$ be two consecutive values in the sorted list of values received by the left-most node of the skip list at the level $h$, such that $m_{l}\geq m\geq m_{r}$. Clearly either $m_{l}$ or $m_{r}$ is picked as the approximate median, determined by their final right and left ranks. To prove this lemma, we shall quantify the maximum possible number of values discarded from range ($m_{l}$, $m_{r}$) at any level.

Let $S^{x}_{d}$ denote the set of values that node $x$ receives at level $d$ from nodes at level $d-1$ (including own values of node $x$). From the construction of the skip list, it is ensured that no two consecutive nodes are supported by less than $a/2$ or more than $2a$ nodes. Therefore, size $|S^{x}_{d}|$ for any node $x$ at any level $d>\left\lceil\log_{a/2}h\right\rceil+2$ must be in between $a^{2}h/2$ and $2a^{2}h$. Let $I^{x}_{d}$ denote the sampling interval for node $x$ at level $d$. Obviously, $I^{x}_{d}=\frac{|S^{x}_{d}|}{ah}-1$.

Each node $x$ from level $h-1$ (i.e. $x\in l_{h-1}$) contributes $ah$ values to the sorted list processed by the left-most node at level $h$. Therefore, any node $x\in l_{h-1}$ can discard at most $I^{x}_{h-1}$ values between $m_{l}$ and $m_{r}$. To maximize the number of values discarded between $m_{l}$ and $m_{r}$, each of $I^{x}_{h-1}$ values between $m_{l}$ and $m_{r}$ in $S^{x}_{h-1}$ must come from different nodes at the lower level $h-2$. Let $s\in S^{x}_{h-1}$, thus $s$ is one of the sampled values from node $y\in l_{h-2}$. if $m_{l}<s<m_{r}$, then there can be at most $2I^{y}_{h-2}$ values from range $(m_{l},m_{r})$ in $S^{y}_{h-2}$ (considering two sampling intervals from both sides). Hence, $S^{y}_{h-2}$ can have at most $2I^{y}_{h-2}+1$ values at level $h-2$ from range $(m_{l},m_{r})$.

Again to maximize the number of discarded values from range $(m_{l},m_{r})$, all these $2I^{y}_{h-2}+1$ values must come from all possible $I^{y}_{h-2}+1$ nodes at level $h-3$; only one node from level $h-3$ contributes one (sampled) value, and each of rest of the $I^{y}_{h-2}$ nodes contributes 2 values each. Therefore, for any node $x\in l_{h-3}$, there can be at most $3I^{x}_{h-2}+2$ values from range $(m_{l},m_{r})$ in $S^{x}_{h-2}$.

Similar reasoning can show that there can be at most $(h-k-1)I^{x}_{k}+k$ values from range $(m_{l},m_{r})$ in $S^{x}_{k}$ for any node $x\in l_{k}$, where $k=\left\lceil\log_{a/2}h\right\rceil+2$. However, $S^{x}_{k}$ has $(ah+1)I^{x}_{k}$ nodes and $k$ is the lowest level where values were discarded through sampling. Since $\frac{(h-k-1)I^{x}_{k}+k}{(ah+1)I^{x}_{k}}<\frac{1}{a}$, there are less than $n/a$ values in between $m_{l}$ and $m_{r}$. Thus at least one of the values between $m_{l}$ and $m_{r}$ must fall in the range of ranks $\frac{n}{2}\pm\frac{n}{2a}$. ∎

VI Analysis

Appendix A-A presents a list of frequently used notations used in this section.

Lemma 2**.**

Let $g_{d}$ be a group at level $d$ and $x$ be a node in $g_{d}$ in skip graph $S$. Let $G_{x}(V,E)$ be a communication graph where $V$ is the set of all nodes in $S$ and $E$ represents only communications during the time period starting from time $T^{x}_{d}$, and ending at time $t$ (inclusive). All nodes $y\in g_{d}$ with $T^{y}_{d}>T^{x}_{d}$ are connected in $G_{x}$.

Proof.

We present a proof by induction for this lemma. Let us assume that the lemma holds for all groups in $S_{t}$. We show that the lemma holds for $S_{t+1}$ as well. Let nodes $u_{t}$ and $v_{t}$ communicate at time $t$. By assumption, the lemma holds for all groups of nodes $u_{t}$ and $v_{t}$ in $S_{t}$. Now, since nodes $u_{t}$ and $v_{t}$ get connected in the communication graph at time $t$, priority rule P2 and timestamp rule T2 ensure that the lemma holds for any newly formed group containing nodes $u_{t}$ and $v_{t}$ in $S_{t+1}$.

Now, for any newly formed group in $S_{t+1}$ that does not contain nodes $u_{t}$ and $v_{t}$, there are two possibilities. The first possibility is that all nodes of such a new group had a positive priority during the transformation from $S_{t}$ to $S_{t+1}$ while receiving $M$ for level $d$. For this case, the lemma holds because (1) all these nodes were in at least one group of either $u_{t}$ or $v_{t}$ in $S_{t}$, and (2) timestamp rule T3 ensures that the new timestamps for the corresponding level are consistent with the lemma. The second possibility is that all node of the new group had a negative priority for level $d$ during the transformation. Such a new group can only be created by a split of a group of size greater than two-third of the number of nodes in the corresponding linked list. Because of the use of boolean variable is-dominating-group, these groups are identical of one of the groups in $S_{t}$ at level $d+1$. Hence the lemma holds.

Now we analyze the base case for induction. Clearly, the lemma holds for $S_{1}$ since all groups are the only member of their groups. Now, from the construction of the algorithm, it is easy to see that the lemma holds for $S_{2}$ as the groups with size $>1$ are the groups that contain nodes $u_{1}$ and $u_{2}$ and timestamp rules T1 ensures that the timestamps in $S_{2}$ are consistent.

∎

Lemma 3**.**

Let $g_{d}$ be a group at level $d$ in $S_{t}$ such that for all pair of nodes $(x,y)\in g_{d}$, distance $d_{S_{t}}(x,y)=O(\log T_{t}(x,y))$, where $T_{t}(x,y)$ is the working set number for the node pair $(x,y)$ at time $t$. If $g_{d}$ is split into 2 new (sub)groups at level $d$ in $S_{t+1}$ due to a negative $M$, for all pair of nodes $(x,y)\in g_{d}$, $d_{S_{t+1}}(x,y)=O(\log T_{t+1}(x,y))$.

Proof.

Let us consider a pair (x,y) such that the distance between nodes $x$ and $y$ increased due to the split (i.e. $d_{S_{t+1}}(x,y)>d_{S_{t}}(x,y)$). Then one of the nodes from pair $(x,y)$ must move to the 0-subgraph and the other node must move to the 1-subgraph at level $d$ in $S_{t+1}$. Let us assume that, node $x$ moves to the 0-subgraph and node $y$ moves to the 1-subgraph.

A group can split due to a negative $M$ only if the size of the group is bigger than two-third of the size of the corresponding linked list. From Section IV-C, clearly nodes moving to the 1-subgroup (due to a split resulted by negative $M$) have $D^{x}_{d}=True$. Now, nodes set is-dominating-group as $True$ only on formation of a group (due to a positive $M$) that contains the communicating nodes. Hence, according to the timestamp rule T2, all nodes $x$ with $D^{x}_{d}=True$ have $T^{x}_{d}\geq M_{p}$, where $M_{p}$ is the positive priority used (in past) to set $D^{x}_{d}=True$. This implies that, after time $M_{p}$, the node $x$ did not communicate with any of the nodes in the group moving to 1-subgraph. According to the definition of working set number, this implies that at least $T_{t}(x,y)$ nodes move to the 1-subgraph due to the split resulted by a negative $M$.

We construct a communication graph $G_{M}$ with communications during the time period starting from time $M_{p}$ and ending at the current time $t$ (inclusive). According to Lemma 2, all nodes moved to the 1-subgraph are connected in $G_{M}$. Lemma 1 implies that the number of nodes moved to the 1-subgraph is at most $\frac{n^{\prime}}{2}+\frac{n^{\prime}}{2a}$, where $n^{\prime}$ is the size of the corresponding linked list. This follows:

[TABLE]

∎

Lemma 4**.**

Given that nodes $u$ and $v$ communicate at time $t$, there exists a direct link between nodes $u$ and $v$ in $S_{t+1}$ at a level no higher than $\log_{\frac{2a}{a+1}}n$.

Proof.

As described in the case 1 in Section IV-C, any group containing communicating nodes $u$ and $v$ at any level $d$ can split at level $d+1$ only if the nodes in the group receive a positive $M$. Now, according to Lemma 1, a positive $M$ can split a subgraph of size $n$ into two subgraphs where size of any of the new subgraphs is at most $\frac{n}{2}+\frac{n}{2a}$. Since communicating nodes always receive a positive $M$, the maximum possible height in $S_{t+1}$ at which nodes $u$ and $v$ move to a subgraph of size 2 is $\log_{\frac{n}{\frac{n}{2}+\frac{n}{2a}}}n=\log_{\frac{2a}{a+1}}n$.

∎

Lemma 5**.**

The maximum possible height after a transformation by DSG is $\log_{\frac{3}{2}}n$.

Proof.

Algorithm DSG split a subgraphs into two smaller subgraphs at the immediate upper level. From Section IV-C, it is easy to see that a subgraph of size $n$ can split into two subgraphs where the size of any of the new subgraphs is at most $\frac{2n}{3}$. Therefore, the maximum possible height of the skip graph after a transformation is $\log_{\frac{3}{2}}n$.

∎

Theorem 2**.**

At any time $t$, given that any two nodes $u$ and $v$ communicated earlier, the distance between $u$ and $v$ in skip graph $S_{t}$ is $O(\log T_{t}(u,v))$, where $T_{t}(u,v)$ is the working set number for the node pair $(u,v)$ at time $t$.

Proof.

Let $t^{\prime}$ be a time between $t$ and the last time $u$ and $v$ communicated. Let $k$ be the longest common postfix between $m(u)$ and $m(v)$ in skip graph $S_{t^{\prime}}$, then the distance between $u$ and $v$ in $S_{t^{\prime}}$ is at most $ak$. Suppose node $u_{t}$ communicates with node $v_{t}$ at time $t^{\prime}$. Let $z=H_{t}-k$, then there exists a linked list $l_{z}$ at level $z$ such that $u\in l_{z}$, $v\in l_{z}$. Now one of the following four cases must occur:

Case 1: $u_{t}\in l_{z}$, $v_{t}\in l_{z}$, and $u_{t}$ and $v_{t}$ are in the same linked lists at level $z+1$. Clearly, the distance between $u$ and $v$ remains unchanged in skip graph $S_{t+1}$.

Case 2: $u_{t}\in l_{z}$, $v_{t}\in l_{z}$, and $u_{t}$ and $v_{t}$ are in two different linked lists at level $z+1$. Clearly, the distance between $u$ and $v$ cannot be increased in skip graph $S_{t+1}$.

Case 3: $u_{t}\in l_{z}$, $v_{t}\notin l_{z}$ or vice versa. We analyze only the case when $u_{t}\in l_{z}$, $v_{t}\notin l_{z}$, and analysis for the opposite case $u_{t}\notin l_{z}$, $v_{t}\in l_{z}$ is similar. Since $u$ and $v$ communicated earlier, they must hold the same group-id for level $z$, i.e. $G^{u}_{z}=G^{v}_{z}$. Let $g^{u}_{z}$ be the group at level $z$ that contains both nodes $u$ and $v$. Let $\alpha$ be the highest common level in $S_{t^{\prime}}$ for communicating nodes $u_{t}$ and $v_{t}$. Then if $u_{t}\not\in g^{u}_{z}$, the rearrangement will not increase the distance between $u$ and $v$ unless the group $g^{u}_{z}$ splits at level $z$ due to a negative $M$ (case 2 in Section IV-C). According to Lemma 3, the distance between $u$ and $v$ in skip graph $S_{t^{\prime}+1}$ remains $O(\log T_{t^{\prime}+1}(u,v))$, even if group $g^{u}_{z}$ splits at level $z$ due to a negative $M$.

Now, if $u_{t}\in g^{u}_{z}$, let $X=\{x\in l_{\alpha}|P(x)>\min(P(u),P(v))\}$. we argue that $|X|\leq T_{t^{\prime}+1}(u,v)$, which proves the lemma for this case since $d_{S_{t^{\prime}+1}}(u,v)=O(\log|X|)$. Let $l^{u}_{\alpha+1}$ and $l^{v}_{\alpha+1}$ be the linked lists in $S_{t^{\prime}+1}$ at level $\alpha+1$ such that $u_{t}\in l^{u}_{\alpha+1}$ and $v_{t}\in l^{v}_{\alpha+1}$. We construct a communication graph $G^{\prime}$ for communications during the time period between the time $\min(P(u),P(v))$ and the current time $t$ (inclusive). According to Lemma 2, all nodes $x\in l^{u}_{\alpha+1}$ with $P(x)>\min(P(u),P(v))$ are connected in the communication graph $G^{\prime}$. Similarly, all nodes $x\in l^{v}_{\alpha+1}$ with $P(x)>\min(P(u),P(v))$ are connected in communication graph $G^{\prime}$ as well. Now since nodes $u_{t}$ and $v_{t}$ communicate at time $t^{\prime}$, all nodes $x\in X$ must be connected in $G^{\prime}$. Based on our definition of working set number, $|X|\leq T_{t^{\prime}+1}(u,v)$ follows.

Case 4: $u_{t}\notin l_{z}$, $v_{t}\notin l_{z}$. Two possible scenarios under this case: (1) neither node $u_{t}$ nor node $v_{t}$ belongs to the group of nodes $u$ and $v$ at any level; and (2) node $u_{t}$, or node $v_{t}$, or both nodes $u_{t}$ and $v_{t}$ belong to the group of nodes $u$ and $v$ at a level lower than $z$. The first scenario is equivalent to the scenario $G^{u_{t}}_{z}\neq G^{u}_{z}$ described in case 3. To analyze the second scenario, let $z^{\prime}$ be the level such that $G^{u_{t}}_{z^{\prime}}=G^{u}_{z^{\prime}}=G^{u}_{z^{\prime}}$. Now as transformation takes place recursively at different levels, the scenario is equivalent to the scenario $u_{t}\in g^{u}_{z}$ described in case 3 as long as both nodes $u$ and $v$ move to the 0-subgraph. However, if both nodes $u$ and $v$ move to the 1-subgraph at some level, the scenario becomes equivalent to the scenario $G^{u_{t}}_{z}\neq G^{u}_{z}$ described in case 3.

∎

Theorem 3**.**

Given a communication sequence $\sigma$, the expected running time of algorithm DSG is $(WS(\sigma))^{2}$ rounds.

The proof relies on the fact that the most expensive operation performed by DSG is to find the approximate median priority for all involved levels for communication request $\sigma_{t}$. The most expensive operation performed by a single call of algorithm AMF is to construct the balanced skip list. Due to the randomization involved in construction, the expected time to construct a balanced skip list is $O(h)$, where $h$ is the height of the skip list.

Theorem 4**.**

The routing cost for algorithm DSG is at most a constant factor more than the the amortized routing cost of the optimal algorithm.

Proof.

Follows from Theorems 1 and 2. ∎

Theorem 5**.**

The cost for algorithm DSG is at most logarithmic factor more than the amortized cost of the optimal algorithm.

Proof.

Follows from Theorems 1 and 3. ∎

VII Conclusion

We present a self-adjusting algorithm for skip graphs that relies on the idea of grouping frequently communicating nodes at different levels and using timestamps to determine nodes’ attachments with their groups. We believe this study will lead to a general framework for distributed data structures with overlapping tree-like structures.

Our algorithm DSG can be useful in networks where multiples levels are involved. For example, VM migration problem in data centers with levels such as rack-level, intra- and inter-data-center level, inter-continental level etc. Moreover, while the amortized routing time for most self-adjusting data structures is $O(\log n)$, our algorithm DSG guarantees $O(\log n)$ routing time for each of the individual communication requests. Thus, compared to most other self-adjusting networks, DSG is better suited for the cases where there is a time limit associated with each of the communications.

Appendix A Appendix

A-A Frequently Used Notations

A-B Standard Skip Graph Routing

The standard skip graph routing [3] works as follows. Routing starts at the top level from the source node and traverses through the skip graph structure. If the identifier of the destination node is greater than that of the source node, then at each level, routing moves to the next right node until the identifier of the next node is greater then the identifier of the destination node. When a node with an identifier greater than the destination node is found, the routing drops to the next lower level, continuing until the destination node is found. If the identifier of the destination nodes is smaller than that of the source node, routing takes place in the similar manner expect it moves to the next left node instead of right, and drops to the lower level when a node with smaller (instead of greater) identifier is found.

A-C Updating group-ids for levels below $\alpha$

DSG requires each node to store a number (between 0 and $H_{t}$), referred to as group-base. The group-base for a node is the highest level at which the node belongs to its biggest group. For example, in the skip graph $S_{8}$ in Figure 4(b), the group-bases for nodes H,F,B and G are 3,2,1 and 1, respectively. We use the notation $B_{x}$ to denote the group-base of any node $x$. Initially, before any communication, group-base for each node is set to the lowest level at which the node is singleton. Also, the notification message sent after routing includes the group-bases for both nodes $u$ and $v$, along with group-ids, timestamps, and membership vectors.

Each node $x\in l_{\alpha}$ with $G^{x}_{\alpha}=u$ initializes a vector $G_{lower}$ as follows:

[TABLE]

Node $u$ broadcasts a message \big{\langle}G_{lower},\min(B_{u},B_{v}),G^{u}_{\max(B_{u},B_{v})},G^{v}_{\max(B_{u},B_{v})}\big{\rangle} to all nodes $y\in l_{\max(B_{u},B_{v})}$ such that $u,v\in l_{\max(B_{u},B_{v})}$. Each such node $y$ with $G^{y}_{\max(B_{u},B_{v})}=G^{u}_{\max(B_{u},B_{v})}$ or $G^{y}_{\max(B_{u},B_{v})}=G^{v}_{\max(B_{u},B_{v})}$ updates their group-base by setting $B_{y}=\min(B_{u},B_{v})$ and updates group-ids $G^{y}_{i}=G_{lower}[i]$ for $i=0,1,\dots\alpha-1$.

Regardless of the outcome of the comparison $\min(B_{u},B_{v})<\alpha$, each node $x\in l_{\alpha}$ with $G^{x}_{\alpha}=u$ sets group-ids $G^{x}_{i}=G_{lower}[i]$ for $i=0,1,\dots\alpha-1$. Moreover, each node $x\in l_{\alpha}$ updates its group-base $B_{x}$ as follows:

• –

If $x$’s group at any level $d$ ($d\geq\alpha$) splits into 2 subgroups due to transformation, and if $B_{x}=d$, $x$ sets $B_{x}=B_{x}-1$.

• –

Let $d$ be the lowest level at which $x$’s group splits due to transformation. if $B_{x}=\alpha$ and $d>\alpha+1$, $x$ sets $B_{x}=d-1$.

It is important to understand that if $G^{u}_{\alpha-1}\neq G^{v}_{\alpha-1}$, then the working set number for the node pair $(u,v)$ is greater than the routing distance for $(u,v)$.

A-D Distributed Sum Using a Skip List

Each node holds a number and we want to compute the sum of the numbers held by all the nodes. Each node of the base level of the skip list forwards their number to the nearest neighbor that steps up to the upper level of the skip list. Any node receiving numbers from the neighbors from lower level computes the sum of the numbers and forwards the sum to the nearest neighbor stepping up to the upper level. As this happens recursively at each level, the head node of the skip list computes the final sum in $O(\log n)$ rounds and then broadcasts the sum to all the nodes.