Synchronization in Dynamic Networks

TL;DR

This paper develops algorithms for synchronizing nodes in dynamic, asynchronous networks, analyzing how connectivity affects the speed and message size of achieving simultaneous or eventual synchronization.

Contribution

It introduces synchronization algorithms for dynamic networks with unknown sizes and start times, linking their efficiency to network connectivity levels.

Findings

High connectivity enables constant-time, constant-message synchronization.

Weaker connectivity results in linear-time, long-message synchronization.

Randomization and size knowledge can improve synchronization algorithms.

Abstract

In this article, we study algorithms for dynamic networks with asynchronous start, i.e., each node may start running the algorithm in a different round. Inactive nodes transmit only heartbeats, which contain no information but can be detected by active nodes. We make no assumption on the way the nodes are awakened, except that for each node u there is a time $s_u$ in which it is awakened and starts to run the algorithm. The identities of the nodes are not mutually known, and the network size is unknown as well. We present synchronization algorithms, which guarantee that after a finite number of rounds, all nodes hold the same round number, which is incremented by one each round thereafter. We study the time complexity and message size required for synchronization, and specifically for simultaneous synchronization, in which all nodes synchronize their round numbers at exactly the same round. We show that there is a strong relation between the complexity of simultaneous synchronization and the connectivity of the dynamic graphs: With high connectivity which guarantees that messages can be broadcasted in a constant number of rounds, simultaneous synchronization by all nodes can be obtained by a deterministic algorithm within a constant number of rounds, and with messages of constant size. With a weaker connectivity, which only guarantees that the broadcast time is proportional to the network size, our algorithms still achieve simultaneous synchronization, but within linear time and long messages. We also discuss how information on the network size and randomization may improve synchronization algorithms, and show related impossibility results.

Equations

$$|{\Gamma }_{\mathrm{in}}(S)\setminus S|⩾\min (c,|\overline{S}|)$$

$$W(t)=\big{\{}u\in V\ :\ r_{u}(t)=\min_{v\in V}\big{(}r_{v}(t)\big{)}\big{\}}\enspace.$$

$$\forall v\in V,r_v(t_0+1)⩽T.$$

$$|H{O}_u(t)|⩾\min \left((1-c)+\frac{c}{T}\left(r_u(t)+1\right),n\right).$$

$$|H{O}_u(t)|⩾ck+1⩾c\left(\frac{r_u(t)+1}{T}-1\right)+1=(1-c)+\frac{c}{T}\left(r_u(t)+1\right).$$

$$|H{O}_u(t)|⩾(1-c)+\frac{c}{T}\left(r_u(t)+1\right)$$

$$H{O}_u(t+1)\subseteq \bigcup _{s⩾s_u}{\mathrm{In}}_u^{\ast }(s:t).$$

$$|H{O}_u(t_0+1)|⩽\lceil \frac{c}{T}\left(r_u(t_0+1)+1\right)\rceil -c.$$

$$r_u(t_0+1)=r_v(t_0+1)=t_0+1-s_{max}=\underset{w\in V}{\min }{r}_w(t_0+1).$$

$$\mathrm{Pr}\left(\left|W-|I|\right|>2\epsilon |I|/3\right)⩽2\exp \left(-{\epsilon }^2\ell /27\right).$$

$$\mathrm{Pr}\left[\forall u\in V,\forall i,Y_u^{(i)}\in \left[\eta /(4\ell N),\ln (4\ell N/\eta )\right]\right]>1-\eta /2,$$

$$|{\nu }_v(t)|⩾\min \left(r_v(t+1)+1,n\right).$$

$$\forall v\in V,\forall t⩾t_0+1,r_v(t)=t-s_{\max }.$$

$$\forall v\in V,\forall t⩾t_0+1,{\nu }_v(t)=\tilde{n}.$$

$${\rm{Pr}}\big{[}\,\left|\,n_{v}(t+1)-\nu_{v}(t)\,\right|>2\,\nu_{v}(t)/9\,\big{]}\leqslant 2\exp\left(-\ell/243\right)\enspace.$$

$$\left|n_v(t+1)-{\nu }_v(t)\right|⩽2{\nu }_v(t)/9\Rightarrow n_v(t+1)⩾2r_v(t+1)/3.$$

$$\left|\tilde{n}-n\right|⩽2n/9$$

$$\forall v\in V,r_v(2n+s_{\max })=2n\text{mbox}and{\nu }_v(2n+s_{\max })=\tilde{n}.$$

$$n+s_{\max }⩽\theta ⩽2n+s_{\max }.$$

Full text

We present synchronization algorithms, which guarantee that after a finite number of rounds, all nodes hold the same round number, which is incremented by one each round thereafter. We study the time complexity and message size required for synchronization, and specifically for simultaneous synchronization, in which all nodes synchronize their round numbers at exactly the same round.

We show that there is a strong relation between the complexity of simultaneous synchronization and the connectivity of the dynamic graphs: With high connectivity which guarantees that messages can be broadcasted in a constant number of rounds, simultaneous synchronization by all nodes can be obtained by a deterministic algorithm within a constant number of rounds, and with messages of constant size. With a weaker connectivity, which only guarantees that the broadcast time is proportional to the network size, our algorithms still achieve simultaneous synchronization, but within linear time and long messages.

We also discuss how information on the network size and randomization may improve synchronization algorithms, and show related impossibility results.

1 Introduction

We study distributed algorithms for dynamic networks over an arbitrary finite set of nodes $V$ that operate in synchronized rounds, communicate by broadcast messages, and in which the inter-node connectivity may change each round of communication. The node identities, and even the cardinality of the set $V$, are not mutually known.

In previous works it was typically assumed that algorithms in such dynamic networks are started simultaneously by all nodes, and consequently that all nodes share the true round number (which is incremented by one each round). In this paper we relax this assumption, and consider a model in which round numbers are unknown to the nodes, and further that each node may start running the algorithm in a different round. This relaxation is natural in environments with no central control which monitors the nodes activities. To make our results more general, we do not make any assumption on the way a node may become active and start running the algorithm, except that eventually all nodes are active.

In this model, we study the basic question of synchronizing the network, in the sense that we wish to ensure that eventually all nodes share the same round number. More specifically, we will focus on the following two levels of synchronization: (a) implementing local round counters that are eventually all equal, and (b) synchronizing the nodes themselves – and not only their round counters – i.e., detecting the synchronization of the local round counters simultaneously.

Simultaneous synchronization (b) can be useful in various situations such as real-time processing (where processors have to carry out some external actions simultaneously), distributed initiation (to force nodes to begin some computation in unison), or distributed termination (to guarantee that nodes complete their computation at the same round). It actually coincides with the Firing Squad problem [2, 6, 7]: a node fires when it detects synchronization of the round counters. In the context of clock synchronization, our results imply conditions under which a simultaneous phase synchronization can be achieved in dynamic networks, given that the local clocks of the nodes have the same frequency (see eg [15]).

We investigate these two levels of synchronization in the context of dynamic networks: the communication topology may continuously and unpredictably change from one round to the next. In particular, we do not assume any stability of the links. We examine various connectivity properties that hold, not necessary round by round, but globally over finite periods of consecutive rounds [9].

Our synchronisation algorithms demonstrate a strong relation between the possibility and cost of synchronizing a network, and the time required to broadcast a message from each node in the network: perhaps a bit surprisingly, when broadcasts from all nodes are possible within a constant number of rounds, a simultaneous synchronization can be achieved by a simple algorithm within a constant number of rounds, using messages of constant size. When broadcast time is linear in the network size $n$, we still achieve simultaneous synchronization in time which is proportional to broadcast time (i.e., linear time), but with messages of size $\Omega(n\log(n))$. When broadcast from each node is possible but there is no bound on the number of required rounds, simultaneous synchronization is not possible, but the simple synchronization of round counters is still achievable within finite time.

We then study models in which some bound $N$ on the network size is known. We present there few impossibility results and algorithms, including a randomized algorithm that assumes an oblivious adversary and performs simultaneous synchronization in linear time with high probability, but with messages which are considerably shorter than the ones used by our deterministic algorithm for the same task.

Related work. Synchronization problems in distributed systems have been extensively studied, but most of works assumed a fixed topology [16] or a complete graph and at most $f$ faulty nodes [11], i.e., a fixed core of at least $n-f$ nodes.

Our work is closely related to the article by Kuhn et al. [10] on distributed computation in dynamic networks: some of our results are based on the generalization to asynchronous starts of their approach for counting the size of the network. In turn, our algorithms provide solutions to distributed computations with asynchronous starts. In  [17] a different model of networks with asynchronous start is studied, in which inactive nodes do not submit any signal, and hence, unlike in our model, their existence cannot be detected by active node - a property which is essential for our results.

2 The Model

We consider a networked system with a fixed set of $n$ nodes. Nodes have unique identifiers and the set of the $n$ identifiers is denoted by $V$. The identities of the nodes are not mutually known, and the network size is unknown as well.

Each node is initially passive: it is part of the network, but sends only heartbeats – that we call null messages – and does not change its state. Upon the receipt of a special signal, it becomes active, sets up its local variables (with its initial state), and starts executing its code.

Execution proceeds in synchronized rounds: in a round $t~{}(t=1,2\dots$), each node, be it active or passive, attempts to send messages to all nodes, receives messages from some nodes, and finally goes to a new state and proceeds to round $t+1$. The round number $t$ is used for a reference, but is unknown to the nodes. Synchronized rounds are communication closed in the sense that no node receives messages in round $t$ that are sent in a round different from $t$.

Communications that occur at round $t$ are modeled by a directed graph $G(t)=(V,E_{t})$ that may change from round to round in dynamic networks [3]. We assume a self-loop at each node in all the graphs $G(t)$ since any node can communicate with itself instantaneously.

In each execution, every node $u$ is assumed to receive a unique start signal at the beginning of some round $s_{u}$. Each execution of the entire system is thus determined by the list $\left(s_{u}\right)_{u\in V}$ of rounds at which nodes become active, by the collection of initial states, and by the sequence of directed graphs $\left(G(t)\right)_{t\in\mathds{N}}$, that we call a dynamic graph.

The way start signals are generated is left arbitrary: they could be sent by an external oracle (environment), or they could be generated endogenously as in the case of diffusive computations initiated by a subset of nodes. Similarly, the sequence of directed graphs can be decided ahead of time or, endogenously as in influence systems [5].

2.1 Paths and broken paths in a round interval

We now fix some notation and introduce some terminology that will be used throughout this paper. First, let us fix an execution of an algorithm with the list of rounds $\left(s_{u}\right)_{u\in V}$ at which nodes become active and the dynamic communication graph $\left(G(t)\right)_{t\in\mathds{N}}$.

If $x_{u}$ is a local variable of node $u$, then $x_{u}(t)$ denotes the value of $x_{u}$ at the beginning of round $t$. Thus $x_{u}(t)$ is undefined for $t<s_{u}$. We let $G^{*}(t)=(V,E^{*}_{t})$ denote the directed graph of edges that transmit non-null messages at round $t\/$: $(u,v)\in E^{*}_{t}$ if and only if it is an edge of $G(t)$ and $u$ is active at round $t$. We denote the sets of $u$’s incoming neighbors (in-neighbors for short) in the directed graphs $G(t)$ and $G^{*}(t)$ by ${\mathrm{In}}_{u}(t)$ and ${\mathrm{In}}_{u}^{*}(t)$, respectively.

We recall that the product of two directed graphs $G=(V,E)$ and $H=(V,E^{\prime})$, denoted $G\circ H$, is the directed graph with the set of nodes $V$ and with an edge $(u,v)$ if there exists $w\in V$ such that $(u,w)\in E$ and $(w,v)\in E^{\prime}$. For $t^{\prime}>t\geqslant 1$, we let $G(t:t^{\prime})=G(t)\circ G(t+1)\circ\dots\circ G(t^{\prime})$, and by convention, $G(t:t)=G(t)$. Similarly, $G^{*}(t:t^{\prime})=G^{*}(t)\circ G^{*}(t+1)\circ\dots\circ G^{*}(t^{\prime})$.

Let ${\mathrm{In}}_{u}(t:t^{\prime})$ and ${\mathrm{In}}_{u}^{*}(t:t^{\prime})$ denote the sets of $u$’s in-neighbors in $G(t:t^{\prime})$ and in $G^{*}(t:t^{\prime})$, respectively. A directed edge $(v,u)$ of $G(t:t^{\prime})$ corresponds to a non-empty set of dynamic paths of the form $P=(v_{0}=v,v_{1},\dots,v_{m}=u)$, where $m=t^{\prime}-t+1$ and $(v_{k},v_{k+1})$ is an edge of $G(t+k)$ for each $k=0,\ldots,m-1$.

We will say that the dynamic path $P$ is broken if one of the edges of $P$ carries a null message, i.e., $t+k>s_{v_{k}}$ for some $k\in\{0,\ldots,m-1\}$. For brevity, we will use the terminology of $v{\sim}u$* path* and $v{\sim}u$* broken path* in the round interval $[t,t^{\prime}]$.

2.2 A hierarchy of synchronization problems

Let $A$ be an algorithm with an integer variable $r_{u}$ for each node $u$, which are aimed at simulating synchronous round counters.

Synchronization:

The algorithm $A$ achieves synchronization if in each execution of $A$ with the start signals $(s_{u})_{u\in V}$, from some round $t_{synch}\geqslant\max_{u\in V}(s_{u})$ onward, the $r_{u}$ counters are incremented by 1 in every round and are all equal, i.e., for every $t\geqslant t_{synch}$,

1. 1.

$r_{u}(t+1)=r_{u}(t)+1$ 2. 2.

$\forall u,v\in V,\ r_{u}(t)=r_{v}(t)$.

In the following each node $u$ is equipped with an additional boolean variable $synch_{u}$ initialized to $false$ at round $s_{u}$.

Synchronization detection:

The algorithm $A$ achieves synchronization detection if it achieves synchronization, and in addition it guarantees that each node eventually detects that the network is synchronized, i.e.,

1. 3.

$\forall u\in V,\ synch_{u}(t)=true\Rightarrow t\geqslant t_{synch}$ 2. 4.

$\forall u\in V,\ \exists t_{u}\in\mathds{N},\ \forall t\geqslant t_{u},\ synch_{u}(t)=true$.

Simultaneous synchronization detection:

The algorithm $A$ achieves simultaneous synchronization detection if all nodes detect synchronization simultaneously, i.e.,

1. 5.

$\forall u,v\in V,\ \forall t\geqslant\max\{s_{u},s_{v}\},\ synch_{u}(t)=synch_{v}(t)$.

Note that the latter condition of simultaneity actually corresponds to the classical Firing Squad problem [6, 2, 7] (i.e., all nodes can fire when the $synch$ variables are set to $true$).

2.3 Completeness and connectivity of dynamic graphs

In this paper we consider the following connectivity conditions in dynamic graphs.

Definition 1**.**

Let $T$ be a positive integer. We say that the dynamic graph $\left(G(t)\right)_{t\geqslant 1}$ is $T$-complete if for every $t\geqslant 1$, the graph $G(t:t+T-1)$ is complete.

Informally, $T$-completeness of a dynamic graph means that a message initiated by any node $u$ in any round $t$ can be broadcasted to all other nodes within $T$ rounds.

We next define dynamic graphs which enable broadcasts in linear time. For that, we first introduce the concept of in-connectivity for directed graphs.

Definition 2**.**

Let $G=(V,E)$ be a directed graph with at least two nodes and let $c<|V|$ be a positive integer. We say that $G$ is $c$ in-connected if for any non-null subset $S$, the following holds:

[TABLE]

where $\Gamma_{\mathrm{in}}(S)$ denotes the set of in-neighbors of $S$ in $G$, and $\overline{S}=V\setminus S$.

Note that $G$ is $|V|-1$ in-connected iff it is complete and that it is 1 in-connected iff it is strongly connected.

One can define in an analogue way the $c$ out-connectivity of a directed graph. The following shows that these definitions are equivalent.

Proposition 3**.**

Let $G$ be a directed graph. For each positive integer $c$ it holds that $G$ is $c$ in-connected iff it is $c$ out-connected

Proof.

We will prove that if $G$ is $c$ in-connected then it is also $c$ out-connected. The proof of the other direction is essentially identical.

Assume for contradiction that $G$ is $c$ in-connected but not $c$ out-connected. Then there is a proper subset $S$ of $V$ s.t. $|\Gamma_{\mathrm{out}}(S)\setminus S|=b<c$, and $|\overline{S}|>b$.

Let $X=\Gamma_{out}(S)\setminus S$, and let $R=\overline{S}\setminus X$. Since $|X|=b$ and $|\overline{S}|>b$, $R$ is not empty. By definition of $R$, there is no edge from a node in $S$ to a node in $R$, meaning that $\Gamma_{\mathrm{in}}(R)\setminus R\subseteq X$. Hence $|\Gamma_{\mathrm{in}}(R)\setminus R|\leqslant b$. Since $\overline{R}=X\cup S$ contains $b+|S|>b$ nodes, this contradicts the assumption that $G$ is $c$ in-connected. ∎

Definition 4**.**

Let $c,T$ be two positive integers. We say that the dynamic graph $\left(G(t)\right)_{t\geqslant 1}$ is ${(c,T)}$ in-connected if for every $t\geqslant 0$, the graph $G(t:t+T-1)$ is $c$ in-connected.

The ${(c,T)}$ in-connectivity implies that a message initiated by any node $u$ in any round $t$ can be broadcasted to all other nodes within $\lceil\frac{T}{c}n\rceil$ rounds (for $c=T=1$, this is implied by a basic inequality on the length of message chains – e.g., Lemma 3.2 in [10] – and the generalization for arbitrary $c$ and $T$ is straightforward).

Finally, we present our weakest connectivity assumption which can be seen as $\infty$-completeness: a message initiated by a node $u$ in round $t$ can be broadcasted to all other nodes, but the time required for this broadcasting is unbounded.

Definition 5**.**

A dynamic graph is said to be eventually strongly connected if for every $t\geqslant 1$, there exists $t^{\prime}\geqslant t$ such that the graph $G(t:t^{\prime})$ is strongly connected.

In the following we will present algorithms which achieve synchronization in the above models. In the first two models, simultaneous synchronization detection is achieved within constant and linear broadcast time, respectively, but with substantially different messages sizes. We will start with the last, weakest model.

3 Synchronization with Unbounded Broadcast Time

In this section, we show how the nodes in any dynamic graph that is eventually strongly connected (and hence guarantees broadcasting in finite but unbounded number of rounds) can eventually synchronize despite asynchronous starts. The synchronization algorithm (Algorithm 1) is simple and does not use identifiers: nodes may be assumed to be anonymous and to have computation and storage capabilities that do not grow with the network size [8].

First let us introduce one notation for the pseudo-codes of all our algorithms: we use $M_{u}^{*}$ to denote the multiset of non-null messages received by $u$ in the current round. Thus $M_{u}^{*}$ at round $t$ is the multiset of messages sent to $u$ by the nodes in ${\mathrm{In}}^{*}_{u}(t)$. If non-null messages are vectors of same size, then ${M_{u}^{*}}^{(i)}$ denotes the multiset of the $i$-th entries of the messages in $M_{u}^{*}$.

Theorem 6**.**

Algorithm 1 achieves synchronization in any dynamic graph that is eventually strongly connected.

Proof.

For any round $t\geqslant s_{\max}=\max_{u\in V}(s_{u})$, we let

[TABLE]

Because of self-loops, we have $W(t)\subseteq W(t+1)$. Moreover, if $W(t)$ has an outgoing edge in the directed graph $G(t)$, then $W(t)\neq W(t+1)$. Eventual connectivity of the dynamic graph ensures that from some round onward, we have $W(t)=V$, which implies the theorem. ∎

We now state two useful lemmas about the way the local round counters $r_{u}$’s evolve in dynamic graphs.

Lemma 7**.**

Assume that $t<t^{\prime}$ and $s_{u}\leqslant t^{\prime}$. Then $r_{u}(t^{\prime})$ is defined and:

If there exists a broken path ending at $u$ in the round interval $[t,t^{\prime}-1]$, then $r_{u}(t^{\prime})\leqslant t^{\prime}-t-1$. 2. 2.

Otherwise, for every $v\in In_{u}(t:t^{\prime}-1)$ it holds that $r_{v}(t)$ is defined and $r_{u}(t^{\prime})\leqslant r_{v}(t)+t^{\prime}-t$.

Proof.

Let $P=(v_{t}=v,v_{t+1},\dots,v_{t^{\prime}}=u)$ be the assumed broken path, and let $(v_{i-1},v_{i})$, be the last edge in $P$ which carries a null message ($t+1\leqslant i\leqslant t^{\prime}$). Then $v_{i}$ is active at round$i$, and by line 4 in Algorithm 1, $r_{v_{i}}(i)=0$ . By easy induction, for $k=i+1,\dots,t^{\prime}$, it holds that $r_{v_{k}}(k)\leqslant k-i\leqslant k-t-1$. Substituting $k=t^{\prime}$, we obtain that $r_{u}(t^{\prime})\leqslant t^{\prime}-t-1$. 2. 2.

If there is no such broken path, then for each $v{\sim}u$ path $P$ as above, no edge in $P$ carries a null message, i.e., node $v_{k}$ is active at round $k$ for each $k=t,\ldots,t^{\prime}-1$.

By line 6 in Algorithm 1 and a straightforward induction, for $k=t+1,\dots,t^{\prime}$, it holds that $r_{v_{k}}(k)\leqslant r_{v}(t)+k-t$. Substituting $k=t^{\prime}$, we obtain that $r_{u}(t^{\prime})\leqslant r_{v}(t)+t^{\prime}-t$.

∎

Lemma 8**.**

For every node $u$ and at every round $t\geqslant s_{\max}=\max_{v\in V}(s_{v})$, we have $r_{u}(t)\geqslant t-s_{\max}$. Moreover, if $t\geqslant s_{\max}+1$ and $\/{\mathrm{In}}_{u}(s_{\max}:t-1)$ contains a node $v$ such that $s_{v}=s_{\max}$, then $r_{u}(t)=t-s_{\max}$.

Proof.

By the definition of $s_{max}$, for each node $u$ we have $r_{u}(s_{max})\geqslant 0$, and an easy induction on $t\geqslant s_{\max}$ shows that $r_{u}(t)\geqslant t-s_{\max}$.

If $\/{\mathrm{In}}_{u}(s_{\max}:t-1)$ contains a node $v$ such that $s_{v}=s_{\max}$, then there is a $v{\sim}u$ path in the round interval $[s_{max},t-1]$. Since all nodes are active on round $s_{\max}$ onward, only non-null messages are sent and all the $v{\sim}u$ paths in the round interval $[s_{max},t-1]$ are non broken. The opposite inequality $r_{u}(t)\leqslant t-s_{\max}$ now follows from Lemma 7.1 and r_{v}\big{(}s_{\max}\big{)}=0. ∎

4 Simultaneous Synchronization Detection with Constant Time Broadcasting

We now show that the synchronization of the round counters can be detected in any $T$-complete dynamic graph. Synchronization detection can be achieved simultaneously by all the nodes in $O(T)$ time using only $O(\log(T))$ bits per message.

Theorem 9**.**

Algorithm 2 achieves Simultaneous Synchronization in any execution on a $T$-complete dynamic graph. Specifically, all nodes detect the synchronization of the $r_{u}$ counters exactly $T$ rounds after all nodes have become active.

Proof.

First, observe that by the first claim in Lemma 8, the condition in line 9, namely $r_{u}\geqslant T$, eventually holds at each node $u$. Moreover, $r_{u}$ may increase by at most 1 in every round, and thus hence there exists at least one round at which $r_{u}$ is equal to $T$.

Let $t_{0}$ be the first round at which some node $u$ sets its variable $r_{u}$ to $T$. Then $r_{u}(t_{0}+1)=T$ and

[TABLE]

Note also that $t_{0}\geqslant r_{u}(t_{0})$, and hence $t_{0}-T+1\geqslant 1$.

By $T$-completeness, ${\mathrm{In}}_{u}(t_{0}-T+1:t_{0})=V$. Since $r_{u}(t_{0}+1)=T$, Lemma 7.1 implies that there is no broken path ending at node $u$ in the interval $[t_{0}-T+1,t_{0}]$. Hence, $s_{max}=\max_{v\in V}(s_{v})\leqslant t_{0}-T+1$ and ${\mathrm{In}}^{*}_{u}(t_{0}-T+1:t_{0})={\mathrm{In}}_{u}(t_{0}-T+1:t_{0})=V$.

In particular, ${\mathrm{In}}^{*}_{u}(t_{0}-T+1:t_{0})$ contains the latest woken-up nodes. Hence, by Lemma 8, $T=r_{u}(t_{0}+1)=t_{0}-s_{\max}+1$ and for every node $v\in V$, $r_{v}(t_{0}+1)\geqslant r_{u}(t_{0}+1)=T$. Since by (1) above $r_{v}(t_{0}+1)\leqslant T$, we get that $r_{v}(t_{0}+1)=T$ for all $v\in V$. By the definition of $t_{0}$, we also have that $r_{v}(t^{\prime})<T$ for $t^{\prime}\leqslant t_{0}$ and for all $v\in V$. Thus all nodes set their local counters to $T$ at round $t_{0}$ for the first time. ∎

Let the synchronization time be the number of rounds from the time the last node is waked up till (simultaneous) synchronization is achieved. Then the synchronization time of any execution of Algorithm 2 is in $O(T)$, and it uses messages of size $O(\log T)$.

5 Simultaneous Synchronization Detection with Linear Time Broadcasting

We now present Algorithm 3 for the simultaneous detection of the counters $r_{u}\,$ in dynamic graphs that are not $T$-complete, but still enjoy good connectivity, namely ${(c,T)}$ in-connectivity, which as mentioned earlier enables broadcasting in time which is linear in the number of nodes. As opposed to the previous algorithm, Algorithm 3 requires unique node identifiers and long messages. Indeed, each node $u$ maintains a variable $HO_{u}$ that contains the identifiers of all the active nodes of which $u$ has heard of since it became active, and broadcasts $HO_{u}$ in each round.

The correctness proof of the algorithm relies on the following inequality, which can be seen as a generalization of a basic inequality established for global round numbers $t$ (e.g., Lemma 3.2 of [10]) to local round counters $r_{u}$.

Lemma 10**.**

In each execution of Algorithm 3 in a ${(c,T)}$ in-connected dynamic graph, for each node $u$ and each round $t\geqslant s_{u}$, it holds that

[TABLE]

Proof.

For $t=s_{u}$, we have $r_{u}(t)=0$ and the proof is immediate.

Suppose now that $t\geqslant s_{u}+1$, and let $q$ and $r$ two nonnegative integers such that $t=qT+r$ with $1\leqslant r\leqslant T$. By induction, we construct a sequence of $q+1$ sets of nodes $S_{0},S_{1},\dots,$ as follows:

$S_{0}=\{u\}$. 2. 2.

Suppose that $S_{0},\dots,S_{i}$ are defined and $i<q$. We let H_{i+1}=G\big{(}t-(i+1)T:t-iT-1\big{)}. We distinguish three cases.

1. (a)

$H_{i+1}$ contains no edge $(w,v)$ such that $w\not\in S_{i}$ and $v\in S_{i}$. Then the construction stops. 2. (b)

$H_{i+1}$ contains an edge $(w,v)$ such that $w\not\in S_{i}$ and $v\in S_{i}$, and that corresponds to a $w{\sim}v$ broken path in the round interval $[t-(i+1)T,t-iT-1]$. Then the construction stops. 3. (c)

Otherwise, we let $S_{i+1}={\mathrm{In}}_{u}(t-(i+1)T:t)$.

Let $S_{k}$ denote the last set in the sequence.

A straightforward induction shows that for each node $v\in S_{i}$ there is a $v{\sim}u$ path in the round interval $[t-iT,t]$ which is not broken.

Using the $(c,T)$ connectivity of G, an easy induction shows that the cardinality of each set $S_{i}$ is at least $c\,i+1$, except for the case when the construction is terminated by (a) above, in which case $|S_{k}|$ may be smaller than $ck+1$.

Similarly, by lines (3) and (10) of the algorithm and by the conditions (b) and (c) above, an easy induction shows that $HO_{u}(t)$ contains every set $S_{i}$ for $0\leqslant i\leqslant k$, and in particular $S_{k}\subseteq HO_{u}(t)$. Hence if the construction is terminated by (b), then the cardinality of $HO_{u}(t)$ is at least $ck+1$.

We now distinguish the following three cases:

Construction terminated by (a):

By the ${(c,T)}$ in-connectivity of the dynamic graph, this implies that $S_{k}=V$. It follows that $HO_{u}(t)=V$ and Lemma 10 trivially follows.

Construction terminated by (b):

We first observe that the assumed $w{\sim}v$ broken path in the round interval \big{[}t-(k+1)T,t-kT-1\big{]} can be extended to a $w{\sim}u$ broken path in the interval \big{[}t-(k+1)T,t\big{]}. This implies by Lemma 7.1 that $r_{u}(t)\leqslant(k+1)T-1$ or equivalently that $k\geqslant\frac{r_{u}(t)+1}{T}-1$. Thus we get

[TABLE]

Construction terminated by $k=q\,$:

Thus we get $|HO_{u}(t)|\geqslant cq+1$. As an immediate consequence of Lemma 7.1 and 7.2, we have $r_{u}(t)\leqslant t-1$. With $r\leqslant T$, it follows that $r_{u}(t)\leqslant T(q+1)-1$, and

[TABLE]

which also gives Lemma 10 in this last case.

∎

Theorem 11**.**

In any ${(c,T)}$ in-connected dynamic graph, all nodes in Algorithm 3 achieve simultaneous synchronization detection. Synchronization is detected in less than $\left\lceil\frac{T}{c}\left(n-1\right)\right\rceil+T$ rounds after all nodes have become active.

Proof.

First, observe that by the first claim in Lemma 8 and the fact that the cardinality of each set $HO_{u}$ is at most $n$, the condition in line 11 eventually holds at each node $u$. Moreover, we easily check that at each round $t\geqslant s_{u}$, it holds that

[TABLE]

Let $t_{0}$ be the first round at which the condition in line 11 holds at some node, and let $u$ denote one node such that

[TABLE]

From Lemma 10, we deduce that $HO_{u}(t_{0}+1)=V$. In particular, $HO_{u}(t_{0}+1)$ contains the latest woken-up nodes. Let $v$ denote one such node, ie $s_{v}=s_{\max}$. By (3), there is a $v{\sim}u$ non broken path in some round interval $[s,t_{0}]$ with $s\geqslant s_{u}$. It follows that $s\geqslant s_{v}$. Thereby $t_{0}\geqslant s_{\max}$ and $v\in{\mathrm{In}}_{u}^{*}(s_{\max}:t_{0})$. This implies, by Lemma 8, that

[TABLE]

Using Lemma 10=10 again we get that for all $w\in V$, $H_{w}(t_{0}+1)=V$. Therefore the inequality (4) holds for all nodes in round $t_{0}+1$, and by the definition of $t_{0}$ this is the first round in which this inequality holds for all nodes.

∎

Considering that $c$ and $T$ are constants, the synchronization time of Algorithm 3 is $O(n)$, and it uses messages of size $O(n\log n)$.

A close examination of the proof of Theorem 11, shows that each node actually computes the set $V$, and so its cardinality. In other words, Algorithm 3 solves the problem of counting the network size despite asynchronous starts in any ${(c,T)}$ in-connected dynamic graph, and in particular in any continuously strongly connected dynamic graph.

This should be compared with the impossibility result established by Wattenhofer [17], which shows that if inactive nodes do not transmit any signal, then counting is impossible with asynchronous start. In other words, in the latter network model passive nodes are not considered as part of the network: the set of nodes in the network is thus time-varying while we assume a fixed set $V$ of nodes.

6 Synchronization with Bounds on Network Size

In this section, we show that knowledge of bounds on the network size can sometimes improve our synchronization algorithms.

6.1 Simultaneous Synchronization Detection with linear broadcast time and short messages

We now show that knowledge on network size can be used for reducing the message size required for linear-time simultaneous synchronization in ${(c,T)}$ in-connected dynamic networks. For the sake of simplicity, we assume $c=T=1$ , i.e., dynamic graphs are continuously strongly connected, but all the results can be obviously extended to the general case of in-connectivity.

First, observe that any connected dynamic graph with $n$ nodes is $(n-1)$-complete. Thus one immediate spinoff of Theorem 9 is the following corollary, which provides a solution to the simultaneous synchronization detection problem in strongly connected dynamic graphs when an upper bound $N$ on the network size is known by all nodes.

Corollary 12**.**

If nodes have an upper bound $N$ of the network size, simultaneous synchronization detection can be achieved in any continuously strongly connected dynamic graph in $N$ rounds after all nodes have become active using only $O(log(N))$ bits per message.

When $N$ is significantly larger than the network size $n$, this solution to simultaneous synchronization detection may use much more than $n$ rounds. However, Lemma 10 enables us to extend the randomized algorithm for approximate counting presented in [10, 14] to the case of asynchronous starts, by substituting the local round counters for the round numbers. As we shall show below, this yields a randomized algorithm which has only a loose bound $N$ on the network size $n$, sends short messages, and with high probability enables all nodes to achieve simultaneous synchronization detection within $O(n)$ rounds. For this algorithm, it is assumed that the dynamic graph, and the wakeup times $s_{v}$, are managed by an oblivious adversary, which has no access to the outcomes of the coin tosses made by the algorithm.

The algorithm, denoted ${\cal A}_{N,\eta}$, depends on the two parameters $N$ and $\eta$ where $N$ is an upper bound on the network size and $\eta$ is any real number in $[\,0,1/2\,[$. It works as follows: upon becoming active, each node $u$ generates $\ell$ independent random numbers $Y_{u}^{(1)},\dots,Y^{(\ell)}_{u}$, where the distribution of each $Y_{u}^{(i)}$ is exponential with rate 1. At each round, any active node $u$ first broadcasts the smallest value of the $Y_{v}^{(i)}$’s it has heard of for each index $i$, and then computes from the minimum values it received so far an estimation $n_{u}$ of the cardinality of the set of nodes it heard of. It detects the synchronization of the round counters when its round counter $r_{u}$ is sufficiently larger than $n_{u}$.

The analysis of the algorithm ${\cal A}_{N,\eta}$ relies on the following lemma in [12] which is is an application of the Cramér-Chernoff method (see for instance [1], sections 2.2 and 2.4).

Lemma 13**.**

Let $I$ be a finite set of $\ell$-tuples of independent exponential variables all with rate 1: $I=\left\{\left(Y_{1}^{(1)},\dots,Y_{1}^{(\ell)}\right),\dots,\left(Y_{|I|}^{(1)},\dots,Y_{|I|}^{(\ell)}\right)\right\}$, and let $W:=\frac{\ell}{\sum_{i=1}^{\ell}\min_{1\leqslant j\leqslant|I|}Y_{j}^{(i)}}$.

For any $\varepsilon\in[0,1/2]$, we have

[TABLE]

It follows that for a sufficiently large value of $\ell$, the value of $n_{u}$ at the end of round $t$ provides with high probability a good approximation of the number of active nodes that $u$ has heard of so far. Then by Lemma 10, it follows that with high probability, if $n_{u}<(1-\varepsilon)r_{u}$ then all nodes are active and node $u$ has heard of all. As for Algorithm 3, we may conclude that with high probability, all the nodes detect synchronization at the same round $t_{0}$ and make no false detection.

We fix the precision parameter of the randomized approximate counting algorithm in [10] to $\varepsilon=1/3$, and choose $\ell=\left\lceil 243.(\ln 4N^{2}-\ln\eta)\right\rceil$ to guarantee a final probability of at least $1-\eta$ for successful executions (cf. below). Node $u$ detects synchronization when $n_{u}<2r_{u}/3$ (see Algorithm 4).

One key point of the randomized approximate counting algorithm in [10] lies in the fact that the algorithm still works when the random variables $Y_{u}^{(i)}$ are initialized with rounded and range-restricted approximations of the initial random numbers of the above scheme. More precisely, if we round down each $Y_{u}^{(i)}$ to the next smaller integer power of $13/12$, then the probability that $n_{v}$ is a good approximation of the number of nodes $v$ have heard of (inequality (10) below) still holds. By the definition of the exponential distribution, it is not hard to see that the random variables $Y_{u}^{(i)}$ are all within the range $\left[\eta/(4\ell N),\ln(4\ell N/\eta)\right]$ with high probability, namely

[TABLE]

The two above transformations of rounding and range-restricting can then be combined and yield a collection of random variables denoted $\overline{Y}_{u}^{(i)}$. The correctness proof of the original algorithm with the exponential random variables $Y_{u}^{(i)}$ is still valid when substituting $\overline{Y}_{u}^{(i)}$ for $Y_{u}^{(i)}$ except an additional probability of at most $\eta/2$ of unsuccessful executions in which the range (6) is violated. In addition, the number of distinct variables $\overline{Y}_{u}^{(i)}$ in that range is $O(\log(N\eta^{-1})$, hence each such variable can be represented using $O\left(\log\log(N/\eta)\right)$ bits.

The reader is referred to [14] for more details on the above scheme developed for the model in which all nodes start at round 1 and hold the true round numbers. Below, we only present the points in the correctness proof of ${\cal A}_{N,\eta}$ that are specific to the round counters $r_{u}$.

Theorem 14**.**

In any execution of Algorithm ${\cal A}_{N,\eta}$ on a dynamic graph that is continuously strongly connected with at most $N$ nodes, with probability at least $1-\eta$ all nodes detect the synchronization of the $r_{u}$ counters simultaneously in less than $2n$ rounds after all nodes have become active. The algorithm uses messages of size $O\left(\log(N/\eta).\log\log(N/\eta)\right)$.

Proof.

We fix any real number $\eta\in]\,0,1/2\,]$. For any node $v$ and at each round $t\geqslant s_{v}$, let $\nu_{v}(t)$ denote the number of nodes that $v$ has heard of at the end of round $t$.111Formally, $v$ has heard of $w$ at the end of round $t$ if for some $s\leqslant t$, there is a path $(w=v_{s},\ldots,v_{t}=v)$ where $(v_{i},v_{i+1})\in G(i)$ and both $v_{i}$ and $v_{i+1}$ are active in round $i,i=s,\ldots,t-1$.

For a continuously strongly connected graph, Lemma 10 then reads:

[TABLE]

Let $t_{0}$ be the first round at which some round counter in the network is set to $n$ (the true network size). Using (7), we deduce that all nodes are active at round $t_{0}$ and that every node has heard of all at the end of round $t_{0}$, i.e., $t_{0}\geqslant s_{\max}$ and $\nu_{v}(t_{0})=n$. Then the same argument as in the proof of Theorem 11 shows that all nodes have synchronized at the end of round $t_{0}$, namely

[TABLE]

In particular, we have $t_{0}=n-1+s_{\max}$.

Since $\nu_{v}(t_{0})=n$, every node $v$ computes the same estimate $\tilde{n}$ of $n$ at the end of round $t_{0}$ in its variable $n_{v}$ and keeps this value for $n_{v}$ at all later rounds:

[TABLE]

It follows that if the condition at line 15 holds at some node in round $t\geqslant t_{0}$, then it holds at all nodes in every round $t^{\prime}\geqslant t$.

By Lemma 13, for every node $v\in V$ and every round $t$, $t_{0}\geqslant t\geqslant s_{v}$, we have

[TABLE]

Using (7) and the inequality $r_{v}(t_{0})\leqslant n-1$, we get that at each round $t$, $t_{u}\geqslant t\geqslant s_{v}$, the following implication holds:

[TABLE]

Now observe that each node $v$ makes a true update to $n_{v}$ at line 14 of the algorithm at most $n-1$ times (when the set of nodes it heard of strictly increases). This implies, by the union bound, that the probability that node $v$ does not detect synchronization by round $t_{0}$ is at least $1-2(n-1)\exp\left(-\ell/243\right)$. Using the union bound again and the upper bound $N\geqslant n$, we obtain that the probability that no node detects synchronization by round $t_{0}$ when using the random variables $Y_{u}^{(i)}$ in the algorithm is thus at least $1-2N(N-1)\exp\left(-\ell/243\right)$.

Let $\theta$ denote the first round at which a node detects synchronization, i.e., the condition at line 15 holds for the first time at round $\theta$. The above argument shows that the probability that $\theta\geqslant t_{0}$ is at least $1-2N(N-1)\exp\left(-\ell/243\right)$.

Inequality (10) at round $t=t_{0}$ shows that with probability at least $1-2\exp\left(-\ell/243\right)$, it holds that

[TABLE]

which implies that $\tilde{n}\leqslant 11n/9$. Moreover equations (8) and (9) for $t=2n+s_{\max}\geqslant t_{0}+1$ write:

[TABLE]

It follows that the condition at line 15 holds at round $2n+s_{\max}$, or equivalently $\theta\leqslant 2n+s_{\max}$, with probability at least $1-2\exp\left(-\ell/243\right)$.

In conclusion, with probability at least $1-2N^{2}\exp\left(-\ell/243\right)\geqslant 1-\eta/2$, it holds that

[TABLE]

As explained above, using the approximated variables $\overline{Y}_{u}^{(i)}$ instead of $Y_{u}^{(i)}$ results in an additional probability of at most $\eta/2$ of unsuccessful executions. This shows that with probability at least $1-\eta$, all the nodes correctly and simultaneously detect synchronization of their round counters by round $2n+s_{\max}$.

∎

The terminating variant of ${\cal A}_{N,\eta}$ in which nodes stop executing their code after they have detected synchronization (line 16) thus achieves simultaneous synchronization detection with high probability: running time is in $O(n)$ and messages are of size $O\left(\log(N/\eta).\log\log(N/\eta)\right)$.

6.2 Synchronization detection with unbounded broadcast time

Theorem 6 demonstrates that nodes can eventually synchronize in any dynamic graph that is eventually strongly connected. In this section we show that this synchronization can be detected only if nodes know the exact network size $n$.

We first show that synchronization cannot be detected in such dynamic graphs even if it is given that the network size is either $n$ or $n+1$, for some fixed integer $n$ which is known to the algorithm.

Theorem 15**.**

Synchronization of the $r_{u}$ counters cannot be detected under the sole assumption of eventual connectivity. This result holds even if it is given that the network size is either $n$ or $n+1$, for some (fixed) $n$.

Sketch of proof.

For the sake of contradiction, suppose that there is an algorithm $A$ which detects synchronization in every execution on an eventually connected dynamic graph with $n$ or $n+1$ nodes.

Let $V$ be a set of cardinality $n+1$, let $u$ be a node in $V$, and let $W=V\setminus\{u\}$. Then by our assumption, $A$ achieves synchronization detection in the execution $\cal{E}$ over the dynamic graph $G$ in which each $G(t)$ is $K_{W}$, the complete directed graph over $W$, and all nodes in $W$ are active from the first round. Hence, there is some $t_{0}$ such that every node in $W$ has detected synchronization by round $t_{0}$.

Now consider an execution $\cal{E}^{\prime}$ over a dynamic graph $H$ in which $H(t)=K^{u}_{W}$ for $1\leqslant t\leqslant t_{0}$ where $K^{u}_{W}$ denotes the directed graph over $V$ with the same edges as $K_{W}$, and $H(t)=K_{V}$, the complete directed graph over $V$, for $t>t_{0}$. Assume further that in $\cal{E}^{\prime}$, $s_{v}=1$ for each $v\in W$, and $s_{u}=t_{0}+1$. Then since nodes in $W$ cannot distinguish between $\cal{E}$ and $\cal{E^{\prime}}$ during the first $t_{0}$ rounds, they all incorrectly detect synchronization by round $t_{0}$ in $\cal{E^{\prime}}$, i.e., before $u$ became active. The proof is completed by noting that $H$ is eventually strongly connected over $V$. ∎

Interestingly, the latter impossibility result does not hold anymore when the exact size of the network is known. Indeed, thanks to its knowledge of $n$, each node $u$ can detect that all nodes are active. By Lemma 8, its round counter $r_{u}$ is then minimal amongst all the local round counters, in which case $u$ is considered as ready to synchronize. Then $u$ can determine when nodes in the network are all ready, that is to say all round counters are minimal, and thus are equal.

For that, each node $u$ maintains two sets of node identifiers, namely $HO_{u}$ which is the set of active nodes $u$ has heard of so far, and $OK_{u}$ which is the set of nodes that $u$ knows to be ready to synchronize. The corresponding pseudo-code is given in Algorithm 5.

We now show that synchronization cannot be detected simultaneously by all nodes of an eventually strongly connected network, demonstrating that with respect to synchronization, simultaneity is harder than detection in this network model.

Theorem 16**.**

Simultaneous synchronization detection is impossible in eventually strongly connected dynamic graphs, even if all nodes know the size of the network.

Sketch of proof.

By contradiction, suppose that there is an algorithm ${\cal A}$ that achieves simultaneous synchronization detection in any eventually strongly connected dynamic graph.

Let $S$ denote the star directed graph centered at $u$, and let $S^{T}$ be its transpose. Let $I=(V,E_{I})$ the directed graph with only a self-loop at each node, i.e., $E_{I}=\{(v,v):v\in V\}$.

We consider the execution of $A$ with start signals all received in the first round, and the alternating sequence of directed graphs $G=S,S^{T}\!,S,S^{T}\!,\dots$. The dynamic graph $G$ is eventually strongly connected, and thus all nodes detect synchronization at the same round $t_{F}$.

Now assume that $G(t_{F})=S^{T}$ (the case $G(t_{F})=S$ is similar). From the viewpoint of any node $v\neq u$, $G$ is indistinguishable up to round $t_{F}$ from the dynamic graph $G^{1}$ that is similar to $G$ except at round $t_{F}$ where $G^{1}(t_{F})=I$. Hence all nodes other than $u$ also detect synchronization at round$t_{F}$ with the dynamic graph $G^{1}$. The same holds for node$u$ since the dynamic graph $G^{1}$ is eventually strongly connected.

By repeating this argument $t_{F}$ times, we show that all nodes detect synchronization at round $t_{F}$ in the execution of ${\cal A}$ with start signals all received in the first round, and the dynamic graph $G^{t_{F}}=I,\dots,I,S,S^{T},S,S^{T},\dots$.

From the viewpoint of any node $v\neq u$, the latter execution is indistinguishable up to round $t_{F}$ from the execution with the same dynamic graph $G^{t_{F}}$ and start signals all received in the first round except the one received by $u$ at some round $s_{u}>t_{F}$. In this execution, synchronization is detected earlier than $u$’s start, a contradiction.

∎

7 Conclusion

In this paper, we defined a model of distributed algorithms in which nodes do not start the algorithm simultaneously. We studied algorithms in this model which synchronize the round counters of the nodes in a dynamic network, where the network topology may change each round, there is no information on the network size, and node identities are not mutually known. As opposed to many models of dynamic networks developed for counting or consensus, links are not supposed to be bidirectional, and we assume no stability of the network in time.

We presented several algorithms whose messages size and time complexity highly depend on the connectivity of the topology.

We also showed that with only eventual connectivity assumptions, synchronization detection is impossible unless nodes know the exact size of the network.

Possible extensions of this work involve variations of the model of computation. For instance, it is interesting to know in which other models of connectivity, synchronization can be detected. It is also of interest to determine whether simultaneous synchronization detection is possible in an anonymous dynamic network where nodes have limited storage capabilities and communicate through finite bandwith channels as in [8]. Our adaptation of the randomized algorithm of [10] provides an efficient Monte Carlo solution for this problem, in the case of continuously strongly connected networks.

This raises another question concerning the role of leaders in a dynamic network: does the existence of a leader in an anonymous network may help for synchronization detection? Combined with our strategy for synchronization detection, the Metropolis method (see [13]) yields a deterministic algorithm that achieves simultaneous synchronization detection in $O(n^{3})$ rounds and that works in any anonymous dynamic network with a leader and a bidirectional connected topology. Unfortunately this algorithm uses messages of infinite size (nodes send real numbers) and do not tolerate rounding. The existence of a deterministic algorithm for synchronization detection in polynomial time, with anonymous nodes and bounded bandwith capacity is still an open problem.

Also of interest are dynamic networks which enable the solution of the consensus problem with asynchronous start. This problem could shed light on the relation between consensus algorithms and kernel agreement algorithms of [4].