Token-based Function Computation with Memory

TL;DR

This paper introduces a token-based distributed function computation algorithm with memory that accelerates meeting times of tokens and reduces complexity compared to previous methods, with proven theoretical improvements and robustness enhancements.

Contribution

The paper presents the TCM algorithm, a novel token-based approach with a chasing mechanism that improves meeting times and complexity over the CRW algorithm in various network topologies.

Findings

TCM reduces time complexity by at least √(n/log n) in Erdös-Renyi and complete graphs.

In torus networks, TCM reduces time complexity by log(n)/log(log n).

Simulation shows at least constant factor message complexity improvement.

Abstract

In distributed function computation, each node has an initial value and the goal is to compute a function of these values in a distributed manner. In this paper, we propose a novel token-based approach to compute a wide class of target functions to which we refer as "Token-based function Computation with Memory" (TCM) algorithm. In this approach, node values are attached to tokens and travel across the network. Each pair of travelling tokens would coalesce when they meet, forming a token with a new value as a function of the original token values. In contrast to the Coalescing Random Walk (CRW) algorithm, where token movement is governed by random walk, meeting of tokens in our scheme is accelerated by adopting a novel chasing mechanism. We proved that, compared to the CRW algorithm, the TCM algorithm results in a reduction of time complexity by a factor of at least $\sqrt{n/\log(n)}$ in Erd\"os-Renyi and complete graphs, and by a factor of $\log(n)/\log(\log(n))$ in torus networks. Simulation results show that there is at least a constant factor improvement in the message complexity of TCM algorithm in all considered topologies. Robustness of the CRW and TCM algorithms in the presence of node failure is analyzed. We show that their robustness can be improved by running multiple instances of the algorithms in parallel.

Figures

Tables

Table 1. Table I: Performance Comparison of the TCM and CRW algorithms in terms of time and message complexities.

	Complete graphs	Erdös-Renyi model	Torus networks
TCM	$O\left(\sqrt{n\log \left(n\right)}\right)$	$O\left(\sqrt{n\log \left(n\right)}\right)$	$O\left(n\log \left(\log \left(n\right)\right)\right)$
CRW	$\Theta \left(n\right)$	$\Theta \left(n\right)$	$\Theta \left(n\log \left(n\right)\right)$ [12]
Truncated CRW	$\Theta \left(n\right)$	$\Theta \left(n\right)$	$\Theta \left(n\right)$ [12]

Table 2. (a) Time complexity

	Complete graphs	Erdös-Renyi model	Torus networks
TCM	$O\left(\sqrt{n\log \left(n\right)}\right)$	$O\left(\sqrt{n\log \left(n\right)}\right)$	$O\left(n\log \left(\log \left(n\right)\right)\right)$
CRW	$\Theta \left(n\right)$	$\Theta \left(n\right)$	$\Theta \left(n\log \left(n\right)\right)$ [12]
Truncated CRW	$\Theta \left(n\right)$	$\Theta \left(n\right)$	$\Theta \left(n\right)$ [12]

Table 3. (b) Message complexity

	Complete graphs	Erdös-Renyi model	Torus networks
TCM	$O\left(n\log \left(n\right)\right)$	$O\left(n\log \left(n\right)\right)$	-
CRW	$\Theta \left(n\log \left(n\right)\right)$	$\Theta \left(n\log \left(n\right)\right)$	$\Theta \left(n{\log }^2\left(n\right)\right)$ [12]
Truncated CRW	$\Theta \left(n\log \left(n\right)\right)$	$\Theta \left(n\log \left(n\right)\right)$	$\Theta \left(n{\log }^2\left(n\right)\right)$ [12]

Equations

$$\{\begin{array}{l}1)v_i^{+}=v_j^{+}=g(v_i,v_j),\\ 2)v_i^{+}=e,v_j^{+}=g(v_i,v_j),\end{array}$$

$$T_{CRW}=\sum _{k=2}^n\mathbb{E}\{T_k\}=\sum _{k=2}^n\frac{n-1}{k(k-1)}=(n-1)(1-1/n)\approx n-2.$$

$$M_{CRW}=\sum _{k=2}^n\frac{n-1}{k-1}\approx (n-1)(\log (n-1)+0.577).$$

$$\mathrm{Pr}\{T_{coal}(I{D}_i)\le t\}\ge \mathrm{Pr}\{T_{coal}(I{D}_2)\le t\},2\le i\le n.$$

$$\begin{array}{rl}\mathrm{Pr}\{T_{EH1}(I{D}_2)>4k\}\le & (1-\frac{\mathbb{E}\{|E{H}_1(k/2)|\}}{n}{)}^k\times \mathrm{Pr}\{|E{H}_1(k)|\le \mathbb{E}\{|E{H}_1(k/2)|\}\}\\ & +\mathrm{Pr}\{|E{H}_1(k)|\le \mathbb{E}\{|E{H}_1(k/2)|\}\}\times 1\\ \le & (1-\frac{\mathbb{E}\{|E{H}_1(k/2)|\}}{n}{)}^k+e^{-n/4-\eta k/2}\\ \le & e^{-\sqrt{\log (n)/n}k}+e^{-n/4-\eta k/2},\end{array}$$

$$\mathrm{Pr}\{T_{coal}(I{D}_2)>k\}$$

$$\begin{array}{rl}\mathbb{E}\{T_{run}(n)\}& =\sum _{k=1}^{\infty }\mathrm{Pr}\{T_{run}(n)>k\}=\sum _{k=1}^{\infty }\mathrm{Pr}\{\underset{i\in \{2,\cdots ,n\}}{\max }{T}_{coal}(I{D}_i)>k\}\\ & \le \sum _{k=1}^{\infty }\min (1,\sum _{i\in \{2,\cdots ,n\}}\mathrm{Pr}\{T_{coal}(I{D}_i)>k\})\\ & {\le }^{a}16\sqrt{n\log (n)}+{\int }_{16\sqrt{n\log (n)}}^{\infty }\min (1,(n-1)\times (e^{-\sqrt{\log (n)/n}t/8}+e^{-n/4-\eta t/16}))dt\\ & {\le }^{b}16\sqrt{n\log (n)}+8/\sqrt{n\log (n)}+\frac{16n}{\eta }{e}^{-n/4-\eta \sqrt{n\log (n)}}.\end{array}$$

$$\frac{1}{n-1}\sum _{j\in \{1,\cdots ,n\}\setminus \{i\}}\mathrm{Pr}\{{\zeta }_j(t)=1\},$$

$$P_{selec}=\sum _{m\in \{q|{\zeta }_q(t)=1\}}\sum _{j=0}^{n-2}p\times \mathrm{Pr}\{d_l^{\prime }=j\}\times 1/(j+1)=(k-1)\times p\times \mathbb{E}\{1/(d_l^{\prime }+1)\},$$

$$r(ϵ)$$

$$s.t.\mathrm{Pr}\{v_i=f(v_1^0,\cdots ,v_n^0),\forall i\in \{1,\cdots$$

$$P_{succ}(t+dt)$$

$$=P_{succ}(t)\times {\mathbb{E}}_{c(t)}\left\{\mathrm{Pr}\{F_{[t,t+dt)}|c(t),F_{[0,t)}\}\right\},$$

$${=}^a{P}_{succ}(t)\times {\mathbb{E}}_{c(t)}\{e^{-\lambda c(t)dt}\},$$

$$=P_{succ}(t)\times {\mathbb{E}}_{c(t)}\{1-\lambda c(t)dt\}+O(d{t}^2),$$

$${=}^b{P}_{succ}(t)\times (1-\frac{\lambda n}{t+1}dt).$$

$$\frac{d{P}_{succ}(t)}{dt}=-P_{succ}(t)\frac{\lambda n}{t+1}.$$

$$P_{succ}=\mathbb{E}_{T_{run}(n)}\big{\{}P_{succ}\big{(}T_{run}(n)\big{)}\big{\}}\geq(\mathbb{E}\{T_{run}(n)\}+1)^{-\lambda n}\geq n^{-\lambda n}.$$

$$R>\log ({ϵ}^{-1})n^{\alpha }.$$

$$1-(1-$$

$$\to R\ge$$

$$\mathbb{E}\{c(t)\}=\frac{1}{n}\sum _{i=1}^n\mathrm{Pr}\{T_{coal}(I{D}_i)>t\},$$

$$P_{succ}(t)=\exp\bigg{(}-\lambda\int_{0}^{t}\mathbb{E}\{c(\tau)\}d\tau\bigg{)}.$$

$$\displaystyle P_{succ}=\mathbb{E}_{T_{run}(n)}\big{\{}P_{succ}\big{(}T_{run}(n)\big{)}\big{\}}$$

$$\ge e^{-\gamma n\lambda },$$

$$\mathrm{Pr}\{|E{H}_1(2k)|\le \mathbb{E}\{|E{H}_1(k)|\}\}\le \frac{1}{2}{e}^{-({\mu }_k-{\mu }_{2k}{)}^2/2{\sigma }_{2k}^2}\le e^{-n/4-k\eta }.$$

$$\mathrm{Pr}\{x_{k+1}^i|S_k^i\}\{\begin{array}{l}={\alpha }_k{x}_{k+1}^i\notin S_k^i,\\ \le {\alpha }_k{x}_{k+1}^i\in S_k^i,\end{array}$$

$$\begin{split}\Pr\{x_{k+1}^{i}=a|S_{k}^{i}\}&=\displaystyle\sum_{i^{\prime}=1}^{i-1}\Big{[}\displaystyle\sum_{j=1}^{k^{\prime}}\Pr\{x_{k+1}^{i}=a|x_{j}^{i^{\prime}}=x_{k}^{i},chase_{i},S_{k}^{i}\}\times\Pr\{x_{j}^{i^{\prime}}=x_{k}^{i},chase_{i}|S_{k}^{i}\}\Big{]}\\ &\qquad\qquad+\Pr\{x_{k+1}^{i}=a|RW_{i},S_{k}^{i}\}\times\Pr\{RW_{i}|S_{k}^{i}\}.\end{split}$$

$$\forall {\omega }_1\in \{p,\cdots ,k\},\exists {\omega }_2\in \{j+1,\cdots ,k^{\prime }\},\text{mbox}s.t.\text{mbox}{x}_{{\omega }_1}^i=x_{{\omega }_2}^{i^{\prime }},$$

$$\begin{array}{rl}\mathrm{Pr}\{x_{k+1}^i=a|x_j^{i^{\prime }}=x_k^i,chas{e}_i,S_k^i\}& \ge \mathrm{Pr}\{x_{k+1}^i=b|x_j^{i^{\prime }}=x_k^i,chas{e}_i,S_k^i\}\\ & \forall j,k,\forall a,b\in \{1,\cdots ,n\},a\notin S_k^i,b\in S_k^i.\end{array}$$

$$\mathrm{Pr}\{x_{k+1}^i=a|S_k^i\}\ge \mathrm{Pr}\{x_{k+1}^i=b|S_k^i\},\forall a,b\in \{1,\cdots ,n\},a\notin S_k^i,b\in S_k^i.$$

$$\mathrm{Pr}\{|E{H}_1(t)|=r\}=\left(\genfrac{}{}{0ex}{}{n-1}{r-1}\right)(1-e^{-t/2(n-1)}{)}^{r-1}\times (e^{-t/2(n-1)}{)}^{n-r},$$

$$\mathrm{Pr}\{|E{H}_1(2t)|\le \mathbb{E}\{|E{H}_1(t)|\}\}\le e^{-{\alpha }_{0}t},t\le 2n,$$

$$\mathrm{Pr}\{|E{H}_1(2t)|\le \mathbb{E}\{|E{H}_1(t)|\}\}\le e^{-nD},$$

Full text

I Introduction

Distributed function computation is an essential building block in many network applications where it is required to compute a function of initial values of nodes in a distributed manner. For instance, in wireless sensor networks, distributed inference algorithms can be executed by computing average of the sensor measurements as a subroutine. Examples of distributed inference in sensor networks include transmitter localization [1], parameter estimation [2], and data aggregation [3]. As another application, consider a network with $n$ processors in which each processor has a local utility function and the goal is to obtain the optimal solution of sum of the utility functions subject to some constraints. This problem has frequently arisen in network optimization algorithms such as distributed learning [4], link scheduling [5], and network utility maximization [6]. All these algorithms utilize a distributed sum or average computation subroutine in solving the optimization problems.

Consider the problem of computing a target function $f_{n}(v_{1}^{0},\cdots,v_{n}^{0})$ in a network with $n$ nodes, where $v_{i}^{0}$ is the initial value of node $i$. A common approach is based on constructing spanning trees [7, 8]. In this solution, the values would be sent toward the root where the final result is computed and sent back to all nodes over the spanning tree. Although the spanning tree-based solution is quite efficient in terms of message and time complexities, it is not robust against network perturbations such as node failures or time-varying topologies. For example, the final result may be dramatically corrupted if a node close to the root fails.

To overcome the above drawback of spanning tree-based solutions, recent approaches take advantage of local interactions between nodes [9]. In these approaches, each node $i$ which has a value, chooses one of its neighbors, say node $j$; The two nodes then update their values based on a predefined rule function $g(.,.)$ which is determined by the target function $f_{n}(.)$ (see Lemma II.1). By iterating this process in the entire network, the target function is computed in a distributed manner. Let $v_{i}$ and $v_{j}$ be the current values of nodes $i$ and $j$, respectively. Two possible options for executing the rule function $g(v_{i},v_{j})$ are:

[TABLE]

where $v_{i}^{+}$ and $v_{j}^{+}$ are the updated values of nodes $i$ and $j$, respectively. The value $e$ is the identity element of the rule function $g(.,.)$, i.e. $g(v,e)=g(e,v)=v$ for any value $v$.

The first option in (1) corresponds to the class of distributed algorithms commonly called gossip algorithms [9]. The main advantage of these algorithms is that they are robust against network perturbations due to their simple structure. However, this robust structure is obtained at the expense of huge time and message complexities [9]. For the first option, various updating rule functions have been proposed for specific target functions like average [10], min/max, and sum [11]. For instance, the updating rules $g(v_{i},v_{j})=(v_{i}+v_{j})/2$ and $g(v_{i},v_{j})=\min(v_{i},v_{j})$ can be used to compute average and min functions, respectively.

The second updating option can compute a wide class of target functions including the ones computable by gossip algorithms (see Lemma II.1) and it is much more energy-efficient than the gossip algorithms [12]. This approach can be easily implemented by a token-based algorithm: Suppose that each node has a token at the beginning of the algorithm and passes its initial value to its token. A node is said to be inactive when it does not have a token. If the local clock of an active node like $i$ ticks, it chooses a random neighbor node, like node $j$, and sends its token carrying its value. Upon receiving the token, node $j$ updates its value, and becomes active (if it is not already)111In case of computing the sum function, the updating rule function $g(v_{i},v_{j})$ is $v_{i}+v_{j}$ and the identity element is equal to zero.. Then, node $i$ sets its own value to $e$, and becomes inactive. From token’s view, each token walks in the network, randomly, until it meets another token. The two tokens will then coalesce and form a token with an updated value. This process continues until the result is aggregated in one token. Finally, the last active node can broadcast the result by a controlled flooding mechanism222In section II, we will explain how the last active node broadcasts the final result.. This computation scheme is called Coalescing Random Walk (CRW) algorithm after the coalescing random walks [13].

The CRW algorithm offers comparable performance to spanning tree-based solutions in terms of message complexity [12], making it much more energy-efficient than the gossip algorithms. However, it is still slow due to deficiency in token coalescence when only a few tokens remain in the network. Hence, authors in [12], modified the CRW algorithm in order to improve its running time. In the modified algorithm, which we call the truncated CRW algorithm, at some point of time, the execution of the CRW algorithm is terminated and each active node broadcasts the value of its token via a controlled flooding mechanism, leaving the completion of the computation to each network node. However, this solution does not lead to a significant improvement in time or message complexity [12].

In this paper, we propose a mechanism to speed up the coalescence of tokens. Suppose that each token has a unique identifier (UID) besides its carried value. In the proposed mechanism, each node registers the maximum UID of tokens seen so far, and the outgoing edge taken by the token with the maximum UID. When a token enters a node previously visited by a token with higher UID, it follows the registered outgoing edge. Otherwise, it will go to a random chosen neighbor node, according to a predefined probability. Figure 1 illustrates a scenario where two tokens are left in the network and show how coalescing is expedited in the proposed scheme. Since nodes memorize the outgoing edge of a token with maximum UID they have seen, we call the proposed scheme “Token-based function Computation with Memory” (TCM) Algorithm.

It is interesting to mention an analogy between this scheme and cosmology. Think of tokens in the network as cosmic dusts in space. Accordingly, the process of function computation is like forming a planet from cosmic dusts. By running the TCM algorithm, tokens with small UID (light dusts) are trapped in the set of nodes visited by tokens with higher UID (in the gravitational field of heavy dusts). The coalescing process continues until a single token is left, similar to birth of a planet.

The main contributions of the paper are as follows:

• •

We show that the proposed TCM algorithm, by accelerating coalescing of tokens, reduces the average time complexity by a factor $\sqrt{n/\log(n)}$ in complete graphs and Erdös-Renyi model compared to the CRW algorithm and its truncated version. Furthermore, there is at least $\log(n)/\log(\log(n))$ factor improvement in torus networks. Simulation results show that the TCM algorithm also outperforms the CRW algorithm in terms of message complexity.

• •

In CRW and TCM algorithms, the final result may be corrupted if an active node fails. Hence, it is quite important to study the robustness of these algorithms under node failures. In this regard, we evaluate the performance of CRW and TCM algorithms based on a proposed robustness metric. We show that the robustness can be substantially improved by running multiple instances of the TCM and CRW algorithms in parallel. We prove that, for the CRW algorithm, the required number of instances in order to tolerate the failure rate $\alpha/n$ in complete graphs, is of the order $O(n^{\alpha})$. While the TCM algorithm needs to run only $O(1)$ instances in parallel.

• •

We study the performance of TCM and CRW algorithms under random walk mobility model [14]. Simulation results show that both algorithms can compute the class of target functions defined in Lemma II.1 successfully even in high mobility conditions.

The remainder of the paper is organized as follows: In Section II, the TCM algorithm is described. In Section III, the performances of TCM and CRW algorithms are analyzed and compared for different network topologies. In Section IV, we study the robustness of both algorithms in complete graphs. In Section V, the performances of TCM and CRW algorithms are evaluated through simulations and then compared with analytical results. Finally, we conclude with Section VI.

II The TCM algorithm

II-A System model

Consider a network of $n$ nodes, where each node $i$ has an initial value $v_{i}^{0}$ and the goal is to compute a function $f_{n}(v_{1}^{0},\cdots,v_{n}^{0})$ of initial values in a distributed manner. The topology of the network is represented by a bidirected graph, $G=(V,E)$, with the vertex set $V=\{1,...,n\}$, and the edge set $E\subseteq V\times V$, such that $(i,j)\in E$ if and only if nodes $i$ and $j$ can communicate directly. We index ports of node $i$ with $\{1,\cdots,d_{i}\}$, where $d_{i}$ is the degree of node $i$.

It is assumed that the function $f_{n}(.)$ is symmetric for any permutation $\pi$ of the set $\{1,\cdots,n\}$, i.e. $f_{n}(v_{1}^{0},\cdots,v_{n}^{0})=f_{n}(v_{\pi_{1}}^{0},\cdots,v_{\pi_{n}}^{0})$. This means that it does not matter which node of the network holds which part of the initial values.

II-B Description of the TCM algorithm

Assume that a UID is assigned to each node $i$.333One can use randomized algorithms to assign UIDs. Each node randomly chooses an integer number in the set $\{1,\cdots,kn^{2}\}$. From birthday problem [15], it can be shown that each node gets a UID with high probability if $k$ is large enough. Furthermore, each node can encode its UID with $O(\log(n))$ bits. At the beginning of the algorithm, each node has a token to which it passes its UID and initial value. It is also assumed that each node has an independent clock which ticks according to a Poisson process with rate one. Let the value and UID of the token at node $i$ be $value(i)$ and $ID(i)$, respectively. We denote the token at node $i$ by the vector $[value(i),size(i),ID(i)]$. The role of parameter $size(i)$ will be explained in the next part.

The TCM algorithm computes the target function $f_{n}(.)$ by passing and merging tokens in the network. When a node does not have a token, it becomes inactive until a neighbor node gets in contact with it. Let $memory(i)$ be the maximum UID of the tokens, node $i$ has seen so far. Algorithm 1 describes how and when an active node $i$ sends or merges tokens. The subroutine Send() is executed by each tick of local clock while the subroutine Receive() is activated upon receiving a token from some neighbor node.

Suppose that the local clock of active node $i$ ticks. Node $i$ decides to send the token $[value(i),size(i),ID(i)]$ to a neighbor node. In this respect, we make distinction between two cases:

Case 1- $memory(i)=ID(i)$: In this case, node $i$ decides to pass the token to a random neighbor node with probability $p_{send}$. Thus, node $i$ waits for $\frac{1}{p_{send}}$ number of clock ticks on average before sending out the token. To implement the waiting mechanism, node $i$ will exit the subroutine Send() with probability $1-p_{send}$, each time its clock ticks (line 6). Otherwise, it chooses a random port $j$, sets the $path(i)$ to $j$, and sends the token on that port (lines 7-8).

Case 2- $ID(i)<memory(i)$: In this case, node $i$ sends the token on the port $path(i)$ with probability one.

Now, suppose that node $i$ receives a token $[value,size,ID]$. If node $i$ is inactive, then the received token remains unchanged. Otherwise, it will coalesce with the token at nodes $i$ and the token with greater UID remains in the network (line 15). Then, the parameters $value(i)$, $size(i)$, and $memory(i)$ are updated to $g(value(i),value)$, $size(i)+size$, and $\max(memory(i),ID)$, respectively (lines 16-18). The updating rule function $g(.,.)$ is determined by the target function $f_{n}(.)$ as explained in Lemma II.1. Furthermore, the value $e$ is the identity element of the rule function $g(.,.)$, i.e. $g(v,e)=g(e,v)=v$ for any value $v$.

From top view, each token walks randomly in the network until it enters a node visited by a token with higher UID (Case 1). Then, it follows a path to meet the token with higher UID (Case 2). We call the walking modes in the first and second cases the random walk and chasing modes, respectively. In the random walk mode, a token walks with the lower speed $p_{send}$. Thus, it can be followed by tokens with lower UID more quickly.

II-C Termination of the TCM algorithm

The process in Algorithm 1 continues until a few tokens remain in the network. In order to terminate the algorithm, we consider two options:

• •

Option 1- Assume that the exact network size, $n$, is known by all nodes. Furthermore, each node $i$ has a parameter $size(i)$, beside its initial value which is equal to one at the beginning. The sum of parameters $\{size(i),i\in\{1,\cdots,n\}\}$ can be computed in parallel to the target function. If the parameter $size$ in an active node reaches $n$, it can identify itself as the unique active node in the network. Then, it broadcasts the output of the TCM algorithm to all nodes by controlled flooding, further explained below.

• •

Option 2- Suppose that there exists an upper bound on the network size. Then, the execution time of the TCM algorithm can be adjusted to a time $T_{run}$ such that, on average, at most a constant number of active nodes remain after time $T_{run}$. Afterwards, each active node broadcasts the value of its token including the UID. All nodes can obtain the final result by combining values received from the active nodes. In analyzing the performances of CRW and TCM algorithms, we consider the first option.

In controlled flooding, an active node $i$ sends the value and UID of its token to all neighbor nodes. Each node $j$, upon receiving this message from a node $k$ for the first time, forwards it to all its neighbor nodes except node $k$. Since each message is transmitted on each edge at most twice, the time and message complexities of controlled flooding are $\Theta(\mbox{diam}(G))$ and $\Theta(|E|)$, respectively444In complete graphs, we can employ gossip algorithm proposed in [16] to broadcast the output with time and message complexities of the order $O(\log(n))$ and $O(n\log(n))$, respectively..

The allocation of memory at node $i$ would be: $(memory(i),path(i),size(i),value(i))$ where the possible values of the first three entries are in the set $\{1,\cdots,n\}$. Thus, the TCM algorithm requires at most $\Theta(\log(n))$ bits more storage capacity compared to the CRW algorithm. The next Lemma identifies the class of target functions $f_{n}(v_{1}^{0},\cdots,v_{n}^{0})$ which can be computed by the TCM algorithm.

Lemma II.1**.**

The TCM algorithm can compute a collection of symmetric functions $\{f_{n}(.)\}$ if there exists an updating rule function $g(.,.)$ such that for any permutation $\pi$ of the set $\{1,\cdots,n\}$, we have: $f_{n}(v_{1}^{0},\cdots,v_{n}^{0})=g(f_{k}(v_{\pi_{1}}^{0},\cdots,v_{\pi_{k}}^{0}),f_{n-k}(v^{0}_{\pi_{k+1}},\cdots,v_{\pi_{n}}^{0}))$, $1\leq k\leq n$, $\forall n$.

Proof.

The proof is the same as Lemma 3.1 in [12]. ∎

A wide class of target functions fulfil these requirements such as min/max, average, sum, and exclusive OR. For instance, updating rule functions $g(v_{i},v_{j})=v_{i}+v_{j}$, $g(v_{i},v_{j})=\max(v_{i},v_{j})$, and $g(v_{i},v_{j})=v_{i}\oplus v_{j}$ are used for computing sum, minimum, and exclusive OR functions, respectively. The average function can also be computed by dividing the output of the sum function by the network size which is obtained by summing parameter $size$ of nodes in parallel to computing the sum function.

III Performance Analysis of the CRW and TCM Algorithms

In this section, we study the performances of CRW and TCM algorithms in complete graphs, Erdös-Renyi model, and torus networks. The considered network topologies may resemble different practical networks. For instance, the topology of a wireless network, in which all stations are in transmission range of each other, is typically modelled by a complete graph. A peer-to-peer network such that all nodes can communicate with each other in the overlay network, is another example of complete graphs. As we explain later, the Erdös-Renyi model is frequently used as a model to represent social networks. Furthermore, torus network is a simple structure widely used to model distributed processing systems with grid layout or grid-based wireless sensor networks.

As a prelude to analyze the performance of the TCM algorithm, we first present an analysis of time and message complexities of the CRW algorithm for complete graphs, although the CRW algorithm is already analyzed in [17]. Then, we study time complexity of the TCM algorithm in complete graphs. We also give a naive analysis of message complexity of the TCM algorithm in complete graphs and time/message complexity of both algorithms in Erdös-Renyi model and torus networks. The summary of time and message complexities for the TCM algorithm and the CRW/truncated CRW algorithms are given in Table 1. In complete graphs and Erdös-Renyi model, the TCM algorithm reduces the time complexity at least by a factor $\sqrt{n/\log(n)}$. In the case of torus networks, there is an improvement at least by a factor $\log(n)/\log(\log(n))$ with respect to the CRW algorithm. Furthermore, the message complexity of the TCM algorithm is at most the same as the CRW and truncated CRW algorithms. Simulation results show that there is at least a constant factor improvement in the message complexity by employing the TCM algorithm in all considered topologies.

In analyzing the CRW and TCM algorithms, we assume that each token is transmitted instantaneously. Furthermore, passing a token is counted as sending one message in the network.

III-A Time and message complexities of the CRW algorithm on complete graphs

Let $T_{CRW}$ and $M_{CRW}$ be the average time and message complexities of the CRW algorithms, respectively. Next theorem gives a tight bound on $T_{CRW}$ and $M_{CRW}$.

Theorem III.1**.**

The average time and message complexities of the CRW algorithm in complete graphs are of the orders $\Theta(n)$ and $\Theta(n\log(n))$, respectively.

Proof.

We can represent the process of token coalescing by a Markov chain with the number of active nodes remaining in the network defined as the state (see Fig. 2). The chain undergoes transition from state $k$ to state $k-1$ if a token chooses an active nodes for the next step, which occurs with rate $\frac{k(k-1)}{n-1}$. Let $T_{k}$ be the sojourn time in state $k$. Then the average time complexity is:

[TABLE]

Besides, in state $k$, on average, $(n-1)/(k-1)$ messages are transmitted before observing a coalescing event. Therefore, the average message complexity would be555$\displaystyle\sum_{k=1}^{n}1/k\approx\log(n)+c$ where $c\approx 0.577$ is the Euler-Mascheroni Constant.:

[TABLE]

∎

Thus, the average time and message complexities of CRW algorithm are of the orders $\Theta(n)$ and $\Theta(n\log(n))$, respectively.

III-B Time complexity of TCM algorithm on complete graphs

Let the UIDs of the $n$ tokens at the beginning of the algorithm be denoted as $ID_{1},\cdots,ID_{n}$. Without loss of generality, assume that $ID_{1}>\cdots>ID_{n}$. Throughout this section, we also assume that $p_{send}=\frac{1}{2}$.

Definition III.1**.**

Let $T_{coal}(ID_{i})$, $i=2,\cdots,n$, denote the time that token $ID_{i}$ coalesces with a token with a larger UID. Thus, the algorithm running time would be: $T_{run}(n)=\max_{i\in\{2,\cdots,n\}}T_{coal}(ID_{i})$.

In the TCM algorithm, token $ID_{1}$ walks randomly in the network. In each step, it chooses a random node from the whole set of network nodes except the node where it is currently presented. After taking $j$ steps, the average number of visited nodes by token $ID_{1}$ would be: $n-(n-1)\times(1-1/(n-1))^{j}$.

Definition III.2**.**

We call the set of nodes visited by token $ID_{1}$ during its first $j$ movements the event horizon of $ID_{1}$, and denote it by $EH1(j)$.

Notice that, in the TCM algorithm, when a token gets in the event horizon of token $ID_{1}$, it cannot escape and will eventually coalesce with token $ID_{1}$. We borrowed the term event horizon from general relativity, where it refers to “the point of no return”.

Lemma III.1**.**

The size of event horizon of token $ID_{1}$ after taking $2j$ steps, i.e. $|EH1(2j)|$, is at least $\mathbb{E}\{|EH1(j)|\}\approx n(1-(1-1/n)^{j})$ with probability greater than $1-e^{-n/4-j\eta}$ where constant $\eta\geq 0.05$.

Proof.

See Appendix A in the supplemental material. ∎

Now, we can obtain an upper bound on the average time complexity of the TCM algorithm, from Lemma III.1.

Theorem III.2**.**

In complete graphs, the average time complexity of TCM algorithm is of the order $O(\sqrt{n\log(n)})$.

Proof.

For a complete proof, see Appendix B in the supplemental material. Here, in order to provide better insight about the algorithm, we present a naive analysis, that is based on a modified model of the network, where Poisson assumption for clock ticks is relaxed. Instead, we adopt a slotted model for time, where each token in the chasing mode, takes one step in each time slot. Furthermore, in the random walk mode, we replace the assumption of $p_{send}=\frac{1}{2}$ with sending token every other slot. Tokens which are scheduled to move in a time slot, take steps in a random order.

In our analysis, we utilize the following inequality that we trust is correct, based on intuition and simulation verification:

[TABLE]

As an example, simulation results are given for a network with $n=100$ nodes in Fig. 3.

First, we derive an upper bound on the probability that the token $ID_{2}$ gets in the event horizon of $ID_{1}$ after time slot $t$. According to the simplified timing model, token $ID_{1}$ moves at even time slots and token $ID_{2}$ tries to get in the event horizon of token $ID_{1}$ at the same time slots. In order to obtain the upper bound, we wait for $2k$ time slots to have a big enough event horizon of token $ID_{1}$. Since the size of event horizon in the next $2k$ time slots is equal or greater than the one at time slot $2k$, the probability of not hitting the event horizon in time interval $[2k,4k]$ is less than $(1-|EH_{1}(k)|/n)^{k}$. By bounding $|EH_{1}(k)|$ from below (see Lemma III.1), we have for $k\geq 2\sqrt{n\log(n)}$:

[TABLE]

where the last inequality is obtained by replacing $\mathbb{E}\{|EH_{1}(k/2)|\}\geq\mathbb{E}\{|EH_{1}(\lfloor\sqrt{n\log(n)}\rfloor)|\}$, for $k\geq 2\sqrt{n\log(n)}$.

When token $ID_{2}$ reaches the event horizon of token $ID_{1}$ at time slot $4k$, it takes at most another $4k$ time slots to coalesce with token $ID_{1}$. Because the size of $|EH_{1}(k)|$ is at most $2k$ and the relative velocity of two tokens is $1/2$. From this fact, we have: $\Pr\{T_{coal}(ID_{2})\leq 8k\}\geq\Pr\{T_{EH1}(ID_{2})\leq 4k\}$. From (5), we can obtain the following:

[TABLE]

Now, an upper bound can be derived on the average time complexity:

[TABLE]

(a) From the inequalities in (4) and (6).

(b) Due to $(n-1)\times(e^{-\sqrt{\log(n)/n}t/8}+e^{-n/4-\eta t/16})\leq 1$ for $t\geq 16\sqrt{n\log(n)}$.

From (7), we conclude that the average time complexity is of the order $O(\sqrt{n\log(n)})$. Comparing with the CRW algorithm, the TCM algorithm improves the time complexity with at least a factor of $\sqrt{n/\log(n)}$.

∎

III-C Message complexity of TCM algorithm on complete graphs

In this part, we give a naive analysis of the message complexity of TCM algorithm in complete graphs. To obtain the bound on message complexity, we will show that the average number of messages sent in the TCM algorithm until observing a coalescing event, is less than the case for the CRW algorithm.

Proposition III.1**.**

The average message complexity of the TCM algorithm is of the order $O(n\log(n))$ in complete graphs.

Proof.

Assume that clock of an active node $i$ ticks at time $t$ and $k$ tokens remain in the network. Suppose that token $ID_{r}$ is in node $i$. The token $ID_{r}$ may be in two different modes: Walking randomly or following another token with higher UID. In the first mode, it will choose any node like $j$ with probability $1/(n-1)$. Thus, the probability of coalescing is:

[TABLE]

where $\zeta_{j}(t)$ is an indicator parameter which is equal to one if node $j$ is active at time $t$ and otherwise, it is zero. But the expected number of active nodes excluding node $i$ is: $\displaystyle\sum_{j\in\{1,\cdots,n\}\setminus\{i\}}1\times\Pr\{\zeta_{j}(t)=1\}=k-1$. Hence, the probability of coalescing in this mode is $(k-1)/(n-1)$.

In the second mode, token $ID_{r}$ follows another token with higher UID and decided to go to a neighbor node, let say node $l$. We know that there exist $k-1$ tokens excluding token $ID_{r}$ which walk randomly or follow another token on a trajectory of a random walk. Thus, node $l$ is active with probability at least $(k-1)/(n-1)$. Following the same arguments in analyzing the message complexity of the CRW algorithm, the message complexity is of the order $O(n\log(n))$.

∎

III-D Time and message complexities of TCM and CRW algorithms in Erdös-Renyi model

In some network applications, it is required to compute a specific function in social networks, such as majority voting [18]. Hence, it is quite important to study the performances of TCM and CRW algorithms in these scenarios. Erdös-Renyi model is frequently used as a simple model to represent social networks [19]. In this part, we use this model to give a naive analysis on the time and message complexities of TCM and CRW algorithms in social networks.

In Erdös-Renyi model, there exists an edge between any two nodes with probability $p$. It can be shown that the graph is almost certainly connected, if $p\geq 2\log(n)/n$ [20]. The next two propositions give upper bounds on the time and message complexities of CRW and TCM algorithms.

Proposition III.2**.**

In the Erdös-Renyi model, the average time and message complexities of CRW algorithm are of the order $O(n)$ and $O(n\log(n))$, respectively.

Proof.

Assume that $k$ tokens remain in the network. Consider token $ID_{i}$ walks randomly until it meets another token. In each step, it may be located in any node. From the token’s view, it seems that edges are randomly established with probability $p$ in each step. Suppose that token $ID_{i}$ is in node $l$ at time $t$. It will choose an active node with probability, $P_{selec}$:

[TABLE]

where $d^{\prime}_{l}$ is the degree of node $l$ excluding an active node $m$. The first term in summation shows the probability of having an edge between two nodes $l$ and $m$. The second term represents the probability that node $l$ has $j$ number of neighbor nodes excluding the node $m$ and the last term is the probability that node $l$ chooses active node $m$ from the set of its neighbor nodes. From Jensen’s inequality and convexity of function $f(x)=1/(x+1)$ over $x>0$, we have: $P_{selec}\geq(k-1)p/(\mathbb{E}\{d^{\prime}_{l}\}+1)=(k-1)/(n-2+1/p)\geq(k-1)/(n-2+n/(2\log(n)))$. It can be easily verified that $P_{selec}\geq(k-1)/(1.12(n-1))=\Theta((k-1)/(n-1))$ for $n\geq 100$. Following the same arguments in analyzing the performance of CRW algorithm in complete graphs, we can deduce that the time and message complexities are of the order $O(n)$ and $O(n\log(n))$, respectively. ∎

Proposition III.3**.**

In the Erdös-Renyi model, the average time and message complexities of TCM algorithm are of the orders $O(\sqrt{n\log(n)})$ and $O(n\log(n))$, respectively.

Proof.

Suppose that the token $ID_{i}$ is in random walk mode. In each step, it visits each node with probability $p\times\mathbb{E}\{1/(d^{\prime}_{l}+1)\}\geq 1/(n-2+1/p)\approx 1/(n-1)$ for large enough $n$. Intuitively, we still have the same bounds on the probabilities $\Pr\{T_{coal}(ID_{i})>t\}$, $2\leq i\leq n$. By the same arguments for the case of complete graphs, the time and message complexities are of the order $O(\sqrt{n\log(n)})$ and $O(n\log(n))$, respectively. ∎

III-E Time complexity of TCM algorithm on torus networks

In this part, we give a naive analysis on the time complexity of TCM algorithm in torus networks. We will show that the average running time of the algorithm is of the order $O(n\log(\log(n)))$. To obtain the bound, we first need to review two lemmas about single random walks.

Lemma III.2**.**

[21]** Consider a $\sqrt{n}\times\sqrt{n}$ discrete torus. Let $T_{hit}$ be the average time for a single random walk to hit the set of nodes contained in a disc of radius $r<\mathcal{R}/2$ around a point $x$ starting from the boundary of a disc of radius $\mathcal{R}$ around $x$. Then, we have: $\mathbb{E}\{T_{hit}\}=\Theta(n\log(r^{-1}))$.

Lemma III.3**.**

[22]** Let $V_{k}$ be the number of nodes visited by a single random walk on $\mathbb{Z}^{2}$ after $k$ steps. Then, we have: $\mathbb{E}\{V_{k}\}=\frac{\pi k}{\log{k}}$ and variance $\mathrm{Var}(V_{k})=O(k^{2}\frac{\log(\log(k))}{\log(k)^{3}})$.

Proposition III.4**.**

In torus networks, the average time complexity of the TCM algorithm is of the order $O(n\log(\log(n)))$.

Proof.

Consider the token $ID_{1}$. From Lemma III.3, $\frac{\pi k}{\log{k}}$ number of nodes are visited on average by token $ID_{1}$ after $k$ steps. To simplify the analysis, we approximate the region of visited nodes with a disc of radius $\sqrt{k/n\log{k}}$ on a unit torus (see Fig. 4). Hence, after $k=\beta n$ steps, radius of the disc would be $\sqrt{\beta/\log(\beta n)}$ where $\beta<<1$. Furthermore, any other token $ID_{i}$ ($i\geq 2$) walks randomly or follows another token on a trajectory of a random walk. Hence, from Lemma III.2, token $ID_{i}$ hits the disc after $\Theta(n\log(\log(n)))$ average time units if it does not coalesce with any other token during this time interval. Following that, at most $2n$ time slots are required to reach token $ID_{1}$. Therefore, the time complexity is of the order $O(n\log(\log(n)))$. ∎

IV Robustness Analysis

In this section, we study the robustness of CRW and TCM algorithms. In the literature of distributed systems, identifying robust algorithms is done mostly from a qualitative rather than quantitative perspective. For instance, there is a common belief that gossip algorithms have a robust structure against network perturbations such as node failures or time-varying topologies [9]. Nevertheless, this advantage is achieved by huge time and message complexities [9].

To the best of our knowledge, there exist a few works [23, 24] on analyzing the robustness of distributed function computation (DCF) algorithms. One of the main challenges is that it is difficult to devise a well defined robustness metric. Despite the challenges, there exist some methodologies for defining a robustness metric in a computing system [25, 26]. Here, we follow the same approach in these methodologies. To do so, three steps should be taken:

1. First, a metric should be considered for the system performance. In our case, we consider it as the probability of successful computation at the end of the algorithm, i.e. \Pr\{v_{i}=f(v_{1}^{0},\cdots,v_{n}^{0}),\forall i\in\{1,\cdots,n\},\mbox{ node i has not failed}\} where $v_{i}$ is the output of node $i$. Note that the correct result is a function of initial values of whole nodes.

2. In the second step, network perturbations should be modelled. In the CRW and TCM algorithms, the final result may be corrupted if an active node fails. Thus, studying the impact of such event on the robustness of these algorithms is quite important. In order to model node failures, we assume that each node may crash according to exponential distribution with rate $\lambda$. Therefore, the average lifespan of a node is $1/\lambda$. As a result, at most $n\times(1-e^{-\lambda\mathbb{E}\{T_{run}(n)\}})$ number of nodes fail on average. We assume that the expected number of crashed nodes during the execution of the algorithm is at most a small fraction of network size, i.e. $\lambda\mathbb{E}\{T_{run}(n)\}<-\log(1-\alpha)\approx\alpha$ where $\alpha<<1$.

3. At the end, it should be identified how much perturbation the algorithm can tolerate such that the performance metric remains in an acceptable region. For this purpose, we define the following robustness metric.

Definition IV.1**.**

The robustness metric, $r(\epsilon)$, is defined by the following equation:

[TABLE]

Intuitively, the robustness metric shows maximum failure rate which an algorithm can tolerate such that the probability of successful computation is greater than a desired threshold, $1-\epsilon$. In order to execute CRW and TCM algorithms in the presence of node failure, it is assumed that each token chooses a random neighbor node for the next clock tick, if the contacting node at the current moment has been failed.

IV-A Robustness of CRW algorithm in complete graphs

We first derive the probability that node $i$ is active at time $t$, i.e. $\Pr\{\zeta_{i}(t)=1\}$.

Lemma IV.1**.**

In the non-failure scenario, node $i$ is active at time $t$ with probability $\Pr\{\zeta_{i}(t)=1\}=1/(t+1)$.

Proof.

We use the mean field theorem to calculate the probability $p(t)=\Pr\{\zeta_{i}(t)=1\}$ (for more on mean field theorem, see [27]). Due to symmetry property of the complete graphs, each node is active at time $t$ with the same probability $p(t)$. Thus, the portion of active nodes will decrease with rate $-p^{2}(t)$. Therefore, we have: $\frac{dp(t)}{dt}=-p^{2}(t)$. By solving the differential equation and considering the fact that $p(0)=1$, we have: $p(t)=1/(t+1)$ and $\mathbb{E}\{c(t)\}=n/(t+1)$ where $c(t)=\displaystyle\sum_{i=1}^{n}\zeta_{i}(t)$ is the the number of active nodes at time $t$. ∎

Lemma IV.2**.**

In the CRW algorithm, the probability of successful computation is greater than $n^{-\lambda n}$ for the node failure rate $\lambda<\alpha/\mathbb{E}\{T_{run}(n)\}$.

Proof.

The function computation is successful iff none of active nodes fail up to time $T_{run}(n)$.666In controlled flooding mechanism, the value of last active node is broadcasted to all nodes. Thus, node failures have negligible impact on the final result in this phase and we neglect it in our analysis. Let $F_{[t_{0},t_{1})}$ be the event that none of active nodes fails in the time interval $[t_{0},t_{1})$. Thus, the probability $P_{succ}(t)\triangleq\Pr\{F_{[0,t)}\},(t<T_{run}(n))$, satisfies the following equation:

[TABLE]

(a) From property of exponential distribution considered in modelling node failures.

(b) We assume that $\mathbb{E}\{c(t)\}\approx n/(t+1)$ is not affected by missing a small fraction of nodes.

Therefore, we have:

[TABLE]

By solving the above differential equation, we have: $P_{succ}(t)=(t+1)^{-\lambda n}$. Hence, we can obtain a lower bound on the probability of successful computation, $P_{succ}$, as follows:

[TABLE]

The above inequality holds due to Jensen’s inequality and considering the fact that function $f(x)=(x+1)^{-n\lambda},x>0$ is convex. ∎

After some manipulations, it can be easily verified that: $r(\epsilon)>\log((1-\epsilon)^{-1})/(n\log(n))$. Hence, the single CRW can tolerate failure rates of order $O(1/(n\log(n)))$. But, how can we improve the performance of this algorithm such that it tolerates failure rates of order $\alpha/\mathbb{E}\{T_{run}(n)\}=\alpha/n$? One effective solution is to run multiple CRWs in parallel. More specifically, we run $R$ instances of CRW algorithm denoted by $1,\dots,R$; As a result, if an active node fails in some instances of the CRW algorithm, it might be inactive in the other instances and those instances survive from that node failure.

In order to run multiple instances of the algorithm, tokens carry the index of the corresponding instance in the execution of the algorithm and can only coalesce with token of the same index. At the end of the algorithm, nodes decide on the output of an instance which includes as many values as possible in computing the target function. To do so, we can assume that each node $i$ has a count parameter $size(i)$ which is equal to one at the beginning of the algorithm (see section II). The sum of these count parameters is obtained alongside computing the target function of initial values for each instance of the algorithm. Nodes decide on the output of instance with maximum count parameter.

Lemma IV.3**.**

To tolerate the failure rate of $\alpha/n$ and get the correct result with probability $1-\epsilon$, the number of instances of the CRW algorithm should be greater than:

[TABLE]

Proof.

Assuming that the multiple instances are approximately independent and considering $\lambda=\alpha/n$ and Lemma IV.2, the probability of successful computation of the target function with $R$ instances of CRW algorithm is greater than:

[TABLE]

∎

Corollary IV.1**.**

The CRW algorithm is robust against failing $\alpha$ fraction of nodes by running $O(n^{\alpha})$ instances of CRW algorithm in parallel. Thus, the message complexity is of the order $O(n^{1+\alpha}\log(n))$. Since $\alpha<<1$, this solution imposes low message overhead.

IV-B Robustness of TCM algorithm in complete graphs

To study the robustness of TCM algorithm, we first need to obtain the average percentage of active nodes at time $t$. However, deriving $\mathbb{E}\{c(t)\}/n$ for TCM algorithm in complete graphs is not an easy task as the one for the CRW algorithm. Since it is required to compute the following sum:

[TABLE]

where obtaining $\Pr\{T_{coal}(ID_{i})>t\},\forall i\in\{2,\cdots,n\}$ (or even bounds on them) is quite challenging. In order to simplify the analysis, we consider a form of function $\mathbb{E}\{c(t)\}/n\approx\log_{2}(t+2)/(at^{2}+bt+1)$ where $a=0.23$ and $b=1.8$. The reason for choosing this form is that the average running time is of the order $O(\sqrt{n\log(n)})$ and it can also be fitted properly to the simulation results777From simulation results, the root mean square error (RMSE) of fitted function is less than $10^{-3}$ for all $n\in[100,2500]$.. According to this assumption, we can derive the probability of successful computation by the following lemma.

Lemma IV.4**.**

The probability of successful computation by TCM algorithm is greater than $e^{-\gamma n\lambda}$ in complete graphs where $\gamma\approx 4.13$.

Proof.

By the same arguments in the proof of Lemma IV.2, we have:

[TABLE]

Since $h(t)=e^{-\lambda t}$ is convex and non-increasing and $g(t)=\int_{0}^{t}\mathbb{E}\{c(\tau)\}d\tau$ is concave ($\frac{d}{dt}\mathbb{E}\{c(t)\}<0,t>0$), the $P_{succ}(t)=h(g(t))$ is convex. Hence, we have from Jensen’s inequality:

[TABLE]

where $\int_{0}^{\mathbb{E}\{T_{run}(n)\}}\frac{\log_{2}(\tau+2)}{a\tau^{2}+b\tau+1}d\tau\leq\int_{0}^{\infty}\frac{\log_{2}(\tau+2)}{a\tau^{2}+b\tau+1}d\tau=\gamma$. ∎

Corollary IV.2**.**

From Lemma IV.4, we can see that $r(\epsilon)$ is at least $\epsilon/(\gamma n)$ for a single TCM algorithm. Similar to the CRW algorithm, we can run multiple instances of TCM algorithm in parallel to improve its robustness. In order to tolerate the failure rate of $\alpha/n$, the required number of instances running in parallel should be of the order $O(1)$.

V Simulation Results

In this section, we evaluate the performances of TCM and CRW algorithms through simulation. Simulation results are averaged over 10000 runs for both algorithms in complete graphs, torus networks, and Erdös-Renyi model.

In Fig. 5, average time complexities of TCM and CRW algorithms are given for complete graphs. In the TCM algorithm, $p_{send}$ is set to $\frac{1}{2}$. As it can be seen, simulation results are close to our analysis. Furthermore, the TCM algorithm outperforms the CRW algorithm by a scale factor $\sqrt{n}$. For instance, for $n=256$, the average time complexities of TCM and CRW algorithms are $67$ and $255$ time units, respectively. Hence, the amount of improvement is $255/67=3.81\approx n/(4.5n^{0.5})=3.56$. In Fig. 6, the average message complexities of TCM and CRW algorithms are depicted in complete graphs. As it can be seen, the average message complexity of TCM algorithm is always less than half of the one for the CRW algorithm.

In order to study the effect of parameter $p_{send}$ on the running time of TCM algorithm, the average time complexity is plotted versus $p_{send}$ for the complete graphs in Fig. 7. Intuitively, the event horizon of token $ID_{1}$ grows with a pace inversely proportional to $p_{send}$. On the other hand, the relative velocity of two tokens is approximately related to $1-p_{send}$. Thus, the average time complexity increases as $p_{send}$ goes to zero or one. Furthermore, the optimal $p_{send}$ gets close to $0.5$ as network size increases.

In Fig. 8, we evaluate the average time and message complexities of TCM and CRW algorithms in torus networks. We can see that TCM algorithm has at least a gain of $\log(n)$ in time complexity and a scale factor of $2.85$ in message complexity. In Fig. 9, the average time and message complexities of TCM and CRW algorithms are depicted in Erdös-Renyi model. According to Fig. 9(a), the TCM algorithm has an improvement in time complexity by a factor $\sqrt{n}$. Furthermore, the average message complexity of TCM algorithm is approximately half of the CRW algorithm.

In Fig. 10, the probability of successful computation by running one instance of TCM and CRW algorithms are depicted in the case of complete graphs. The failure rate is set to $0.05/n$. For the TCM algorithm, $P_{succ}$ is approximately equal to $0.83$ for different values of $n$ in the range $[100,400]$. Besides, results from analysis are close to it by an offset of $0.001$. In the case of CRW algorithm, results from the simulation and the analysis are also close to each other. For this algorithm, $P_{succ}$ is greater than $0.74$ for various values of $n$ in the range $[100,400]$.

In Fig. 11(a), the message complexities of the TCM and CRW algorithms are plotted versus failure rate in a complete graph with $n=100$ nodes. The number of parallel instances is determined such that the probability of successful computation is equal to $0.95$. As it can be seen, it is required to run a few more instances of the TCM and CRW algorithms to tolerate higher failure rate. Furthermore, message complexity of the TCM algorithm is less than the one for the CRW algorithm. In Fig. 11(b), the time complexities of both algorithms are given versus failure rate. For higher failure rate, we need to run more instances of the TCM/CRW algorithm to have $P_{succ}=0.95$. On the other hand, executing multiple instance of the algorithms improves the time complexity. Since the target function is computed if any of the instances is terminated successfully.

In Fig. 12, the probabilities of successful computation of the TCM and CRW algorithms are plotted versus number of multiple instances in a complete graph with $n=400$ nodes for the failure rates $\lambda=0.05/n,0.1/n$. It can be seen that the analytical lower bounds in (12) and (17) are close to simulation results. Furthermore, $P_{succ}$ goes to one in all cases when $6$ number of instances are executed in parallel. Thus, the proposed solution makes both algorithms robust against node failures by running a few number of instances in parallel as we expected from Corollaries IV.1 and IV.2.

Studying the impact of dynamic topologies on the performance of distributed algorithms is quite important. Here, we evaluate the performance of TCM and CRW algorithms under node mobility. There exist different mobility models in the literature of mobile ad hoc networks [14]. In the simulations, we consider the Random Walk (RW) mobility model which is frequently used in determining the protocol performance and it can mimic movements of mobile nodes walking in an unpredictable way [14].

Initially, suppose that nodes are located randomly over a square of unit area. Let $[x_{i}(t),y_{i}(t)]$ be the location of node $i$ at time $t$. In the RW mobility model, the differences $x(t+h)-x(t)$ and $y(t+h)-y(t)$ are two independent normally distributed random variables with zero mean and variance $2Dh$ $,\forall h>0$ where $D$ is the diffusion coefficient [28]. Thus, the mean square displacement of a node is related to the parameter $D$. In particular, the probability of large displacement increases as diffusion coefficient $D$ grows. We assumed that if a node reaches the boundary of simulated area, it will be bounced off the boundary according to the same angle. Furthermore, two nodes are neighbor if the distance between them is less than a fixed transmission range. The transmission range is set to a value such that the graph remains connected with high probability for the static case, i.e. $D=0$ [29].

In the TCM algorithm, we assume that each node $i$ registers the UID of the node that the token $memory(i)$ passed to it. Whenever an active node should send a token to a node which is not in its transmission range any more, it will pass its token to a random neighbor node. In Fig. 13, the time and message complexities of TCM and CRW algorithms are depicted versus the parameter $D$ in a network with $n=100$ nodes. It is noteworthy that both algorithms can compute the class of target functions defined in Lemma II.1 successfully even in high mobility networks. Furthermore, the time and message complexities of TCM algorithm increases as the parameter $D$ grows while node mobility improves the performance of CRW algorithm. In fact, higher mobility weakens the advantage of chasing mechanism. On the other hand, it gives an opportunity to a completely randomized solution, i.e. the CRW algorithm, to reduce the coalescing time of distant tokens. Nevertheless, simulation results show that the TCM algorithm outperforms the CRW algorithm in both time and message complexities.

VI Conclusions

In this paper, we proposed the TCM algorithm to compute a wide class of target functions (such as sum, average, min/max, XOR) in a distributed manner. In complete graph and Erdös-Renyi model, we showed that it reduces running time at least by factor $\sqrt{n/\log(n)}$ with respect to completely randomized solution, i.e. the CRW algorithm, and there is at least a factor of $\log(n)/\log(\log(n))$ improvement in torus networks. We defined a robustness metric to study the impact of node failures on the performance of CRW and TCM algorithms. The TCM and CRW algorithms can tolerate the failure rate of $\alpha/n$ by running $O(n^{\alpha})$ and $O(1)$ instances in parallel, respectively. Furthermore, simulation results showed that both algorithm can compute the target functions successfully even in high mobility conditions.

VII Appendix A

Proof of Lemma III.1:

The pdf of $|EH_{1}(k)|$ can be approximated with Gaussian distribution $\mathcal{N}(\mu_{k},\sigma_{k})$ where $\mu_{k}=n-n(1-1/n)^{k}$ and $\sigma_{k}^{2}=n^{2}(1-1/n)(1-2/n)^{k}+n(1-1/n)^{k}-n^{2}(1-1/n)^{2k}$ [29]. After some manipulations, we have:

[TABLE]

where $\eta\geq 0.05$. Hence, the size of the set $EH_{1}(2k)$, is greater than $\mathbb{E}\{|EH_{1}(k)|\}$ with probability at least $1-e^{-n/4-k\eta}$.

VIII Appendix B

Proof of Theorem III.2:

Consider token $ID_{i}$ ($i>1$). Let $x_{k}^{i}$ be the node visited by token $ID_{i}$ at $k$-th step and $S_{k}^{i}=\{x_{1}^{i},\cdots,x_{k}^{i}\}$ be the history of the corresponding walk. We define the walk taken by token $ID_{i}$ as weakly self-avoiding walk, provided that:

[TABLE]

for some $\alpha_{k}$ where $\alpha_{k}\geq\frac{1}{n-1}$. Thus, in a weakly self-avoiding walk, token $ID_{i}$ visits new nodes with higher probability than the visited nodes.

Lemma VIII.1**.**

In the TCM algorithm, the path traced by token $ID_{i}$ ($i>1$) is a weakly self-avoiding walk.

Proof.

Suppose that the token $ID_{i}$ enters a node $x_{k}^{i}$ visited by some other token with higher UID. Let $ID_{i^{\prime}}$ be the maximum UID, node $x_{k}^{i}$ has seen so far. Furthremore, assume that token $ID_{i^{\prime}}$ is in $k^{\prime}$ steps and has visited node $x_{k}^{i}$ in $j$-th step for the last time, i.e. $j=\max_{\omega\leq k^{\prime}}\omega\mbox{ }s.t.\mbox{ }x_{\omega}^{i^{\prime}}=x_{k}^{i}$. We denote the chasing and random walk modes of token $ID_{i}$ by $chase_{i}$ and $RW_{i}$, respectively. Now, for a given history $S_{k}^{i}$, we have:

[TABLE]

Suppose that token $ID_{i}$ was in $l$-th step when token $ID_{i^{\prime}}$ was leaving node $x_{j}^{i^{\prime}}$ (see Fig. 14). We prove that token $ID_{i}$ will not visit nodes in the set $\{x_{l}^{i},\cdots,x_{k}^{i}\}$ in the next step. By contradiction, assume that there exists $l\leq p\leq k$ where $x_{p}^{i}=x_{j+1}^{i^{\prime}}$. However, we have:

[TABLE]

due to the fact that token $ID_{i}$ is chasing token $ID_{i^{\prime}}$. For $\omega_{1}=k$, the above equation asserts that token $ID_{i^{\prime}}$ revisited node $x_{k}^{i}$ in some step later than $j$ which is contradiction.

We know that token $ID_{i^{\prime}}$ was eventually in the random walk mode in $j$-th step. Hence, each node in the set $\{1,\cdots,n\}\backslash\{x_{l}^{i},\cdots,x_{k}^{i}\}$ is selected with probability $1/(n-|\{x_{l}^{i},\cdots,x_{k}^{i}\}|)$ in the $k+1$-th step. Consequently, we have:

[TABLE]

From (20) and (22), it can be concluded that:

[TABLE]

Thus, the proof is complete.

∎

Assume that if token $ID_{i}$ coalesces with token $ID_{j}$ (where $ID_{j}>ID_{i}$), it virtually sticks to token $ID_{j}$. Now, if token $ID_{j}$ meets another token, say $ID_{k}$ with higher UID, token $ID_{j}$ and all tokens attached to it, stick to token $ID_{k}$. This process continues until token $ID_{i}$ hits the event horizon of $ID_{1}$ by itself or another token. We denote the time for token $ID_{i}$ to hit the event horizon of token $ID_{1}$ by $T_{EH1}(ID_{i})$. Furthermore, let $EH_{i}(t)$ be the set of nodes visited by token $ID_{i}$ up to time $t$.

Token $ID_{1}$ takes steps in the network according to a Poisson process with rate $1/2$ (assuming that $p_{send}=1/2$). At each step, it chooses one of nodes except its current node with probability $1/(n-1)$. Thus, each node (excluding the initial node having token $ID_{1}$) is not visited by token $ID_{1}$ up to time $t$ with probability $e^{-t/2(n-1)}$ independently from other nodes. Hence, the pdf of the number of visited nodes at time $t$ is:

[TABLE]

for $1\leq r\leq n-1$.

Lemma VIII.2**.**

We have the following probabilistic bound on the number of visited nodes by token $ID_{1}$ at time $2t$:

[TABLE]

where $\alpha_{0}=(1-\log(2))/4$.

Proof.

From (24) and the proposed upper bound for binomial distribution in [30], we have:

[TABLE]

where $D=a\log(a/b)+(1-a)\log((1-a)/(1-b))$, $a=1-e^{-t/2(n-1)}$ and $b=1-e^{-t/(n-1)}$. Besides, we have:

[TABLE]

From above equation, it can be easily seen that $nD>t(1-\log(2))/4$ for $t\leq 2n$. Therefore, the proof is complete. ∎

Lemma VIII.3**.**

Let $N_{i}(t_{0},t_{0}+2t)$ be the number of steps taken by token $ID_{i}$ in time interval $[t_{0},t_{0}+2t]$. Then, we have the following bound:

[TABLE]

where $\alpha_{1}=\log(\sqrt{e/2})$.

Proof.

The random variable $N_{i}(t_{0},t_{0}+2t)$ is a Poisson process with rate at least $\lambda_{2t}=2t\times 1/2=t$. Thus, we have from the Chernoff bound:

[TABLE]

The proof is complete. ∎

Remark VIII.1**.**

By the same arguments in Lemma VIII.3, it can be shown that: $\Pr\{N_{i}(t_{0},t_{0}+t)>2t\}\leq e^{-\alpha_{2}t}$ where $\alpha_{2}=\log{(4/e)}$.

Given a time $t$, we say that the event $E_{i}(t)$ occurs if $|EH_{1}(t)\backslash EH_{i}(t)|\geq 1/8\sqrt{n\log{n}}$. Let $E(t)=\underset{i}{\bigcap}E_{i}(t)$ and define $t^{\star}=\sqrt{n\log{n}}$. We have:

[TABLE]

(a) The first sum is given according to the union bound. The second sum is greater than the probability of having $|EH_{1}(t^{\star})\cap EH_{i}(t^{\star})|\geq j$ where $P_{EH_{1}(t^{\star})}$ and $P_{EH^{c}_{1}(t^{\star})}$ are the probabilities of choosing a node from the set $EH_{1}(t^{\star})$ and $\{1,\cdots,n\}\backslash EH_{1}(t^{\star})$, respectively.

(b) From Lemma VIII.1, the path traced by token $ID_{i}$ ($i>1$) is a weakly self-avoiding walk. Thus, we have: $P_{EH_{1}(t^{\star})}\leq\frac{|EH_{1}(t^{\star})|}{n-N_{i}(0,t^{\star})}$.

(c) The sum has greater value for larger $|N_{i}(0,t)|$ and smaller $|EH_{1}(t)|$. We can obtain this inequality by bounding the probability $\Pr\{|EH_{1}(t^{\star})|<1/4\sqrt{n\log{n}}\}$ and $\Pr\{N_{i}(0,t^{\star})>2\sqrt{n\log{n}}\}$ from Lemma VIII.2 and Remark VIII.1, respectively.

(d) From Strling’s approximation, the probability is in the order of $O(e^{-\log{n}\sqrt{n\log{n}}})$. Thus, it is less than $1/\sqrt{n\log{n}}$ for large enough $n$.

Lemma VIII.4**.**

Assume that the event $E(t^{\star})$ occurs. Then, the probability of not hitting the event horizon of token $ID_{1}$ by token $ID_{i}$ after $t^{\star}+2t$ is less than the following:

[TABLE]

Proof.

Suppose that the event $E(t^{\star})$ occurs at time $t^{\star}$. Thus, the size of the the set $EH_{1}(t)\backslash EH_{i}(t)$, $t>t^{\star}$, will be greater than $1/8\sqrt{n\log(n)}$ as far as token $ID_{i}$ does not hit it. Hence, the probability of not hitting the event horizon of $ID_{1}$ in time interval $[t^{\star},t^{\star}+2t]$ is less than $(1-1/8\sqrt{n\log{n}}/n)^{N_{i}(t^{\star},t^{\star}+2t)}$. By bounding $N_{i}(t^{\star},t^{\star}+2t)$ from below (see Lemma VIII.3), we have:

[TABLE]

∎

Lemma VIII.5**.**

Suppose that token $ID_{i}$ hits the event horizon of token $ID_{1}$ at time $t$. Then, it will coalesce with token $ID_{1}$ in next $3t$ time units with probability greater than $1-(e^{-\alpha_{3}t}+e^{-\alpha_{4}t})$ where $\alpha_{3}=1/36$ and $\alpha_{4}=\log(2/\sqrt{e})$.

Proof.

In worst case scenario, the event horizon of token $ID_{1}$ is a line with length $N_{1}(0,t)$ and token $ID_{i}$ hits end of the line at time $t$. Thus, token $ID_{i}$ reaches token $ID_{1}$ at time $t^{\prime}$ given in the following equation:

[TABLE]

Let us define random variable $Y(t^{\prime})=N_{i}(t,t^{\prime})-N_{1}(t,t^{\prime})$, which is the difference of two independent Poisson random variables $N_{i}(t,t^{\prime})$ and $N_{1}(t,t^{\prime})$ with rates $(t^{\prime}-t)$ and $(t^{\prime}-t)/2$, respectively. Hence, the random variable $Y(t^{\prime})$ has Skellam distribution and we have:

[TABLE]

Since token $ID_{1}$ takes at most $\lceil t\rceil$ steps in time interval $[0,t]$ with probability $\displaystyle\sum_{i=0}^{\lceil t\rceil}e^{-t/2}\frac{(t/2)^{i}}{i!}\leq e^{-\alpha_{4}t}$, we have:

[TABLE]

∎

Corollary VIII.1**.**

From Lemmas 31 and VIII.5, we have:

[TABLE]

Now, we can obtain an upper bound on the average time complexity:

[TABLE]

(a) Regardless of the event $E(t^{\star})$, token $ID_{1}$ covers the complete graph in $t^{\star}+2n\log(n)$ time units on average [13]. Thus, any token $ID_{i}$ ($i>1$) will coalesce with it in at most $2\times(2n\log{n}+t^{\star})$ time units on average. Hence, we have: $\mathbb{E}\{T_{run}(n)|E^{c}(t^{\star})\}\leq 4n\log{n}+2t^{\star}$. Besides, we know that $\Pr\{E^{c}(t^{\star})\}\leq 1/\sqrt{n\log{n}}$ according to (30).

(b) According to union bound.

(c) From Corollary 36.

(d) From the fact that $ne^{-\frac{1}{128}\sqrt{\log{n}/n}t}\geq 1$ for $t\leq 128\sqrt{n\log{n}}$.