Node-Independent Spanning Trees in Gaussian Networks

TL;DR

This paper introduces constructions of node-independent spanning trees in Gaussian networks, enabling fault-tolerant and secure message routing with improved performance due to their smaller diameter.

Contribution

The paper presents novel methods for constructing node-independent spanning trees specifically in dense Gaussian networks, along with routing and fault-tolerant algorithms.

Findings

Constructed node-independent spanning trees in Gaussian networks.

Designed routing algorithms for fault-tolerance and security.

Developed parallel algorithms for tree construction.

Abstract

Message broadcasting in networks could be carried over spanning trees. A set of spanning trees in the same network is node independent if two conditions are satisfied. First, all trees are rooted at node $r$. Second, for every node $u$ in the network, all trees' paths from $r$ to $u$ are node-disjoint, excluding the end nodes $r$ and $u$. Independent spanning trees have applications in fault-tolerant communications and secure message distributions. Gaussian networks and two-dimensional toroidal networks share similar topological characteristics. They are regular of degree four, symmetric, and node-transitive. Gaussian networks, however, have relatively lesser network diameter that could result in a better performance. This promotes Gaussian networks to be a potential alternative for two-dimensional toroidal networks. In this paper, we present constructions for node independent spanning trees in dense Gaussian networks. Based on these constructions, we design routing algorithms that can be used in fault-tolerant routing and secure message distribution. We also design fault-tolerant algorithms to construct these trees in parallel.

Tables

Table 1. Table 1 : Steps from node 0 to node v = c + d ​ i 𝑣 𝑐 𝑑 𝑖 v=c+di in T k ( 1 ) superscript subscript 𝑇 𝑘 1 T_{k}^{\left(1\right)}

Node $c+di\ne 0$		Path
$1\le c\le k-1$	$1\le d\le k-c$	$1^c{i}^d$
$c=0$	$d=k$	$1^{k+1}$
$c=0$		$1^k{\left(-i\right)}^{k-d}1$
$-k\le c\le -1$	$0\le d\le k+c$	$1^{k+c+1}{\left(-i\right)}^{k-d}$
$-k+1\le c\le 0$	$-k-c\le d\le -1$	$1^{k+c}{i}^{k+d+1}$
$1\le c\le k$	$-k+c\le d\le 0$	$1^c{\left(-i\right)}^{-d}$

Table 2. Table 2: Message routing direction

	$S_1\cup B_1$	$R_1$	$Q_1$	$P_1$
$S_1\cup B_1$	$C_1$	$C_2$	$C_2$	$1^{\left[1\right]}$
$R_1$	$C_3$	$C_4$	$i^{\left[1\right]}$	–
$Q_1$	–	$-i^{\left[3\right]}$	$C_5$	–
$P_1$	$-i^{\left[2\right]}$	–	–	–
$S_2\cup B_2$	$i^{\left[2\right]}$	$C_6$	$C_6$	$i^{\left[2\right]}$
$R_2$	–	–	–	$i^{\left[3\right]}$
$Q_2$	$i^{\left[3\right]}$	–	–	–
$P_2$	$-1^{\left[2\right]}$	–	–	$-1^{\left[2\right]}$
$S_3\cup B_3$	$C_7$	$C_7$	$C_7$	$i^{\left[3\right]}$
$R_3$	–	$-i^{\left[3\right]}$	$-i^{\left[3\right]}$	–
$Q_3$	–	$-i^{\left[3\right]}$	$-i^{\left[3\right]}$	–
$P_3$	$i^{\left[3\right]}$	–	–	–
$S_4\cup B_4$	$-i^{\left[4\right]}$	$-i^{\left[4\right]}$	$C_8$	$-i^{\left[4\right]}$
$R_4$	–	–	–	–
$Q_4$	$i^{\left[3\right]}$	–	–	–
$P_4$	$-1^{\left[4\right]}$	$-1^{\left[4\right]}$	–	$-i^{\left[4\right]}$

Table 3. Table 3: Conditional moves in message routing direction

$C_1$	If	then	$1^{\left[1\right]}$
		else	$-1^{\left[2\right]}$
$C_2$	If $t_x=d_x$	then	$i^{\left[1\right]}$
		else	$1^{\left[1\right]}$
$C_3$	If $t_x=d_x$	then	$-i^{\left[4\right]}$
		else	$-1^{\left[4\right]}$
$C_4$	If	then	$1^{\left[2\right]}$
		else	$-1^{\left[4\right]}$
$C_5$	If $t_x=d_x$	then
		If	then $i^{\left[1\right]}$
			else $-i^{\left[3\right]}$
		else
		If	then $1^{\left[2\right]}$
			else $-1^{\left[4\right]}$
$C_6$	If $t_y=d_y$	then	$1^{\left[2\right]}$
		else	$i^{\left[2\right]}$
$C_7$	If $t_x=-k-1+d_x$	then	$i^{\left[3\right]}$
		else	$-1^{\left[3\right]}$
$C_8$	If $t_y=-k-1+d_y$	then	$-1^{\left[4\right]}$
		else	$-i^{\left[4\right]}$

Table 4. Table 4: A node parent and children edge directions as per the partition in Figure  7

Node in	Parent	Child
$B_1$	$-1$	$+1,\pm i$
$R_1$	$-i$	$+i$
$Q_1$	$-i$	$+i$
$P_1$	$-1$	$+1,\pm i$
$S_1$	$-1$	$+1,\pm i$
$B_2$	$-1$	–
$R_2$	$+i$	$+1,-i$
$Q_2$	$+i$	$-i$
$P_2$	$-1$	–
$S_2$	$-1$	–
$B_3$	$+i$	–
$R_3$	$-i$	–
$Q_3$	$-i$	$+i$
$P_3$	$+i$	–
$S_3$	$+i$	–
$B_4$	$-i$	$+i$
$R_4$	$+i$	$-i$
$Q_4$	$+i$	$-i$
$P_4$	$-i$	$+i$
$S_4$	$-i$	–

Table 5. Table 5: Average maximum number of steps to construct all trees or paths.

$\alpha$	1+2i	2+3i	3+4i	4+5i	5+6i	6+7i	7+8i	8+9i	9+10i
No Faulty	2	3	4	5	6	7	8	9	10
1 Faulty	2	3.333	4.5	5.6	6.666	7.714	8.75	9.777	10.8
2 Faulty	2	3.515	4.847	6.061	7.213	8.329	9.421	10.498	11.563
3 Faulty	2	3.618	5.094	6.417	7.658	8.849	10.009	11.145	12.266

Table 6. Table 6: Maximum of all maximums number of steps to construct all trees or paths.

$\alpha$	1+2i	2+3i	3+4i	4+5i	5+6i	6+7i	7+8i	8+9i	9+10i
No Faulty	2	3	4	5	6	7	8	9	10
1 Faulty	2	4	6	8	10	12	14	16	18
2 Faulty	2	4	6	8	10	12	14	16	18
3 Faulty	2	4	6	8	10	12	14	16	18

Equations

$$E_k^{\left(1\right)}=$$

$$0,1,2,3,3-i,-2+2i\text{.}$$

$$0,i,2i.3i,1+3i,-2-2i\text{.}$$

Full text

Gaussian networks and two-dimensional toroidal networks share similar topological characteristics. They are regular of degree four, symmetric, and node-transitive. Gaussian networks, however, have relatively lesser network diameter that could result in a better performance. This promotes Gaussian networks to be a potential alternative for two-dimensional toroidal networks.

In this paper, we present constructions for node independent spanning trees in dense Gaussian networks. Based on these constructions, we design routing algorithms that can be used in fault-tolerant routing and secure message distribution. We also design fault-tolerant algorithms to construct these trees in parallel.

Keywords: Circulant Graphs, Gaussian Networks, Spanning Trees, Independent Spanning Trees, Fault-Tolerant Routing.

1 Introduction

A parallel computing system interconnection topology decides the system fault-tolerance capabilities as well as the system over all communication efficiency. There are many researches on interconnection networks such as hypercube [12][13], generalized hypercube [5], mesh, $k$–ary $n$–cube [6], torus [8], REFINE [4], and RMRN [2][3] networks; more examples of interconnection netowkrs can be found in [9][11].

An efficient interconnection topology called Gaussian network has been studied in [21][22]. Gaussian networks and two-dimensional toroidal networks share similar topological properties. They are symmetric, node-transitive, and regular degree four. Gaussian networks, however, have relatively lesser diameter which suggests that they could be a potential alternative for two-dimensional toroidal networks. Gaussian networks have been studied in [7][10][16], and they are briefly reviewed in Section 2.

In parallel computing as well as in distributed systems, a network can be represented as a graph where nodes and edges represent processors and communication links among the processors, respectively. A path from a node $s$ to a node $d$ in a graph is a sequence of edges, which connects a sequence of nodes from $s$ to $d$. Two such paths are said to be independent if their nodes are disjoint except for the end nodes $s$ and $d$, i.e. there are no common intermediate nodes in the two paths. A spanning tree is a connected loop-free subgraph of graph $G$ containing all the nodes of graph $G$. Spanning trees rooted at node $r$ are said to be independent if the paths from $r$ to any other node $u$ in any two of the trees are independent.

Node independent spanning trees used to resolve important issues in network applications such as fault-tolerant broadcasting [17][19] and secure message distribution [23][24]. These applications are briefly described below:

• •

Consider the existence of $t$ node independent spanning trees rooted at node $r$ in network $N$. Assume that $N$ contains at most $t-1$ faulty nodes. Then, $r$ can broadcast a message to every non-faulty node $u$ in $N$ by broadcasting the message over all the $t$ trees. Since the number of faulty nodes is less than $t$, at least one of the $t$ node disjoint paths from $r$ to $u$ is fault free.

• •

Node independent spanning trees could be used in secure message distribution over a fault-free network as follows. A message can be divided into $t$ packets where each packet is sent by node $r$ to its destination using a different spanning tree. Thus, each node in the network receives at most one of the $t$ packets except the destination node that receives all the $t$ packets [20][24][25].

In [1], AlBdaiwi et. al. two edge-disjoint node-independent spanning trees were constructed in dense Gaussian network. Such network contains the maximum number of nodes for a given diameter $k$ [22], where the depth of each tree is $2k$, $k\geq 1$. Based on those constructions, algorithms were provided for fault-tolerant routing and secure message distribution where the source node can be any node in the network.

In [15], we gave algorithms for constructing four node independent spanning trees in a dense Gaussian network of depth $k$ working in $2k$ steps where the trees are not necessarily edge-disjoint. In this paper, we extend our work and present a $k$–steps construction algorithm. Furthermore, we develop routing algorithms based on these trees that can be used in fault-tolerant communication and secure message distribution.

The rest of this paper is organized as follows. The Gaussian network is reviewed in Section 2. In Section 3, we introduce a construction of four node independent spanning trees in Gaussian networks. Based on the constructed trees, routing algorithms from a given source node to a given destination node are described in Section 4. Section 5 presents parallel algorithms for constructing the four node independent spanning trees, and Section 6 presents simulation analysis for these algorithms. Finally, The paper is concluded in Section 7.

2 Background

Gaussian networks are regular symmetric networks of degree 4. These networks are based on quotient rings of Gaussian integers $\mathbb{Z}[i]=\{x+yi\mid x,y\in\mathbb{Z}\}$ where $i=\sqrt{-1}$ [14]. $\mathbb{Z}[i]$ is an Euclidean domain. The nodes of the network are elements of the residue class modulo some $\alpha\in\mathbb{Z}[i]$, where $\alpha$ is considered as a network generator. The norm $N(\alpha)=a^{2}+b^{2}$ of a Gaussian network generated by $\alpha=a+bi$, is the total number of nodes in this network. A dense diameter-optimal Gaussian network denoted by $G(\alpha_{k})$, where $\alpha_{k}=k+(k+1)i$, is a $k$ diameter Gaussian network that contains the maximum number of nodes. Note that $\alpha_{k}$ always generates the maximum possible number of nodes within diameter $k$ since GCD$(k,k+1)=1$.

Gaussian networks can be represented in several different ways as described in [18]. In this paper, we deal with graphs isomorphic to dense diameter-optimal Gaussian networks. We denote $G_{k}=(V_{k},E_{k})=G(\alpha_{k})$, $k\geq 1$. Each node in the graph is labeled as $x+yi$ where $|x|+|y|\leq k$. Two nodes $A$ and $B$ are adjacent if and only if $(A-B)\ mod\ \alpha$ is equal to $\pm 1$ or $\pm i$. As described in [21], the number of nodes at distance $j$ from any single node in a dense Gaussian network is $D(j)=4j$ for $j=1,2,\dots,k$. Figure 1 shows an example of Gaussian network generated by $\alpha=3+4i$.

The wraparound edges in Figure 1 can be illustrated as straight lines by tiling the Gaussian network on an infinite grid as depicted in Figure 2. Consider the boundary node $3i$. Its $-1$, $+i$, and $+1$ edges are wraparound links that are connected to the boundary nodes $3$, $-3$, and $-2-i$, respectively. We have kept these edges as wraparounds to show the equivalence of the two illustrations. Note that the different gray color nodes are related to different network tiles.

3 Spanning Trees in $G_{k}=(V_{k},E_{k})$

In this section we describe four spanning trees rooted at node [math] in $G_{k}=\left(V_{k},E_{k}\right)$, $k\geq 2$, and we will show that they are pairwise node independent in Section 4. Any two spanning trees rooted at [math] are node independent when $k=1$. However, a motivation of our research is to tolerate transient node failures, and thus it is assumed that $k\geq 2$.

Lemma 1

In $G_{k}$, $k\geq 2$, there are at most four pairwise node independent spanning trees rooted at node [math].

Proof 3.2**.**

Let there be five such trees. Consider a node $v$ at distance $2$ from the node [math]. In each of the trees there is a path of length at least 2 from the root [math] to $v$. By the pigeonhole principle, there are two of the trees where such path starts by the same edge. Such two trees are not node-independent.

To define our four trees, we will introduce some auxiliary notations. Recall that $\alpha_{k}=k+\left(k+1\right)\mathbf{i}$. Let $E_{k}^{V}=\left\{\left(v,\left(v+\mathbf{i}\right)\operatorname{mod}\alpha_{k}\right);v\in V_{k}\right\}$ denote the set of all vertical edges in $E_{k}$. Clearly, $\left|E_{k}^{V}\right|=\left|V_{k}\right|$. We define the counter clockwise 90${}^{\text{o}}$ rotation mapping $\rho$ on $V_{k}$ as $\rho\left(x+y\mathbf{i}\right)=\left(-y+x\mathbf{i}\right)$. The rotation $\rho$ is a bijection on $V_{k}$. We extend this mapping to the set $E_{k}$; for $\left(u,v\right)\in E_{k}$ we define $\rho\left(u,v\right)=\left(\rho\left(u\right),\rho\left(v\right)\right)$. For a subgraph $G^{\prime}=\left(V^{\prime},E^{\prime}\right)$ of $G_{k}$ we denote $\rho\left(G^{\prime}\right)=\left(\rho\left(V^{\prime}\right),\rho\left(E^{\prime}\right)\right)$.

Now we are ready to describe four trees $\ T_{k}^{\left(j\right)}=\left(V_{k}.E_{k}^{\left(i\right)}\right),j=1,2,3,4$ - see Figures 3–6. In fact, we will define the tree $T_{k}^{\left(1\right)}$ only, since the remaining three trees can be described as $T_{k}^{\left(j\right)}=\rho^{j-1}\left(T_{k}^{\left(1\right)}\right),j=2,3,4$. It is therefore sufficient to define the edge set $E_{k}^{\left(1\right)}$ as follows:

[TABLE]

Lemma 3.3**.**

$T_{k}^{\left(j\right)},j=1,2,3,4$* are spanning trees in $G_{k}$.*

Proof 3.4**.**

Since $\rho$ is a bijection, it is enough to prove that $T_{k}^{\left(1\right)}$ is a spanning tree. Based on the definition of $E^{\left(1\right)}$, the graph $T_{k}^{\left(1\right)}$ consists of $\left|E_{k}^{V}\right|-k-k-1+k+\left(k-1\right)+1=\left|V_{k}\right|-1$ edges. We will show that $T_{k}^{\left(1\right)}$ is connected by showing that there is a path in $T_{k}^{\left(1\right)}$ from the node [math] to each other node $v\in V_{k}.$ We will describe the path by a word on the alphabet $\left\{1,-1,i,-i\right\},$ the symbols denoting the direction of the edges to be passed. The paths are described in Table 1, where the node $v=c+di$, for the values satisfying $\left|c\right|+\left|d\right|\leq k$, is considered.

Lemma 3.5**.**

The height of each of the trees $T_{k}^{\left(j\right)}$ is $2k$, $j=1,2,3,4$.

Proof 3.6**.**

Based on Table 1, the longest path in $T_{k}^{\left(1\right)}$starting from the root [math] of length $2k$ leads to node $i$ or to node $-1$.

Example 3.7**.**

The path from the root [math] to the node $-2+2i$ in $T_{4}^{\left(1\right)}$ is described as $1^{4-2+1}\left(-i\right)^{4-2}=1^{3}\left(-i\right)^{2}$. The path is the sequence

[TABLE]

The path from the root [math] to the node $-2-2i$ in $T_{4}^{\left(2\right)}$ can be obtained the following way. Since $T_{k}^{\left(2\right)}=\rho\left(T_{4}^{\left(1\right)}\right)$, we have to observe the path in $T_{k}^{\left(1\right)}$ from the root [math] to the node $\rho^{-1}\left(-2-2i\right)=-2+2i,$ which is the path (1). The required path in $T_{k}^{\left(2\right)}$ is obtained from (1) by rotating each node using the mapping $\rho$. The resulting path is

[TABLE]

4 Routing Using Node-Independent Spanning Trees

In Section 3, we defined four spanning trees of the graph $G_{k}$ and in Section 5 we give algorithms for their construction. In this section we present routing algorithms for delivering messages along any of the four trees.

Routing a message consists of three types of nodes: source node, transient nodes, and destination node. The source node is the sender who sends a message to a destination node. A transient node is an intermediate node that forwards the message toward the destination node. We will provide a routing algorithm for delivering a message virtually from any node $s$ to any node $d$ in $G_{k}$ along any of the four trees rooted at $r$. We will provide the routing decision in any transient node $t$ on the path from $s$ to $d$ and we will show that such decision can be taken uniquely without information on which of the four trees is involved. This fact implies the independence of the four trees.

Let $s\in V_{k}$. Considering the automorphism $\tau_{s}$ on $G_{k}$ defined for $x\in V_{k}$ as $\tau_{s}\left(x\right)=\left(x+s\right)\operatorname{mod}\alpha_{k}$ and for $\left(x,y\right)\in$ $E_{k}$ as $\tau_{s}\left(\left(x,y\right)\right)=$ $\left(\tau_{s}\left(x\right),\tau_{s}\left(x\right)\right)$ allows us to describe routing for the case $s=0$ only. The routing decisions for messages sent from a node $s\neq 0$ to some node $d$ is then implied by the routing decisions for messages sent from node [math] to node $\left(d-s\right)\operatorname{mod}\alpha_{k}$.

To simplify the routing process, we partition the Gaussian network into disjoint subsets as follows (see Figure 7):

$B_{1}=\{x+yi\mid 1<x<k,y=0\}$,

$R_{1}=\{x+yi\mid k>x>0,y=1\}$,

$Q_{1}=\{x+yi\mid x>0,y>1,x+y\leq k\}$,

$P_{1}=\{x+yi\mid x=k,y=0\}$,

$S_{1}=\{x+yi\mid x=1,y=0\}$,

for $j\in\{2,3,4\}$:

$B_{j}=\rho^{-j+1}(B_{1})$, $R_{j}=\rho^{-j+1}(R_{1})$, $Q_{j}=\rho^{-j+1}(Q_{1})$, $P_{j}=\rho^{-j+1}(P_{1})$, and $S_{j}=\rho^{-j+1}(S_{1})$.

Based on Figure 7, Table 2 shows the direction to which a message sent from the source node [math] is forwarded by a transient node $t=t_{x}+t_{y}i$, based on the location of the destination node $d=d_{x}+d_{y}i\neq t$. The left column denotes the location of the current transient node, the remaining columns denote the location of the destination node. The direction is described by one of the elements in $\{1,-1,i,-i\}$. The superscripts in brackets are to be understood as comments denoting which tree the message is passed along. To determine the direction, in several cases an additional condition is to be evaluated. The direction is then the result of one of the conditional statements listed in the table 3, denoted as $C_{1},\dots,C_{8}$.

Table 2 describes the action of any transient node for the cases when the destination node is in one of the areas from $B_{1}$, $R_{1}$, $Q_{1}$, $P_{1}$, $S_{1}$, only. For the remaining cases, the action is obtained by applying the proper rotation.

Example 4.8**.**

Assume we want to determine the action of a transient node from $B_{2}$ given that the destination node is in $Q_{4}$. Since $Q_{4}=\rho^{3}(Q_{1})$, we have to observe the action described in our table in the row $S_{3}\cup B_{3}$ and column $\rho^{-3}(Q_{4})=Q_{1}$. The action is determined by the conditional statement $C_{7}$. Stated as “If $t_{x}^{\prime}=-k-1+d_{x}^{\prime}$ then $-i^{\left[3\right]}$ else $-1^{\left[3\right]}$”, where $t_{x}^{\prime}+t_{y}^{\prime}i=\rho^{-3}(t_{x}+t_{y}i)=-t_{y}+t_{x}i$ and $d_{x}^{\prime}+d_{y}^{\prime}i=\rho^{-3}(d_{x}+d_{y}i)=-d_{y}+d_{x}i$. Moreover, the actions in the “then” and “else ”cases (as well as the tree indexes) are to be mapped by $\rho^{3}$. Therefore, if the transient node is in $B_{2}$ and the destination node is in $Q_{4}$, the action to be performed is given by the conditional statement “If $-t_{y}=-k-1-d_{y}$ then $-1^{\left[2\right]}$ else $i^{\left[2\right]}$”.

Lemma 4.9**.**

The trees $T_{k}^{\left(j\right)},j=1,2,3,4$ are pairwise independent.

Proof 4.10**.**

The independence follows from the fact that the action of a transient node in each case in Table 2 (and the corresponding rotations) is unique.

The above routing algorithm is simplified in Algorithms 1 and 2 as follows. Let $S=s_{x}+s_{y}i$ be the source node, $T=t_{x}+t_{y}i$ be the transient node, $D=d_{x}+d_{y}i$ be the destination node, and $T^{(j)}_{k}$, $1\leq j\leq 4$, be the tree used for routing. Furthermore, let $\rho^{j}$ be the previously defined rotation where $j$ denotes the number of rotations $mod\ 4$. We define the function degreej($C$) that returns the degree of node $C$ in tree $T^{(j)}_{k}$. The partitions in Figure 7 are considered in the following algorithms.

To send a message from $S$ to $D$ using tree $T^{(j)}_{k}$, the node $S$ calls StartRouting($S$, $D$, $j$) as described in Algorithm 1. Since the network is symmetric, initially, the algorithm maps the source node $S$ to node 0 and all other nodes are assumed mapped accordingly. Then, it starts the routing process by sending the message through the edge that is connected to the neighbor node corresponding to the tree $T^{(j)}_{k}$, $1\leq j\leq 4$. For example, calling StartRouting($S$, $D$, 2) will send a message from node $S$ to node $S+i$ through the $+i$ edge since the $+i$ edge of node $S$ is the initial direction of the tree $T^{(2)}_{k}$.

After that, each receiving node performs the steps described in Algorithm 2 as follows. In lines 1-2, the current node $C$ computes its address relatively to node $S$ after being mapped. In lines 3-5, every transient node which receives the packet ($S$, $D$, $j$) sets the variables dir to be the direction of the receiving edge, $j$ to hold the tree number that is being used for the routing, and $r$ to be the number of rotations required to set the direction of the forwarding edge. Then, in lines 13-14, the transient node checks weather it is the destination node to consume the packet. Otherwise, the rest of the algorithm, the transient node forwards the message through a certain direction (edge) based on its degree and the location of the destination node. Note that, Algorithms 1 and 2 can be used for any $S$ being a root by mapping $S$ and all other nodes accordingly. Since all other nodes are also mapped then the transient node’s addresses are computed relatively to address of node $S$.

Since Algorithm 1 is used only once by the source node, its total communication overhead is 1. Further, the local computation in the algorithm is based on 5 elementary operations as follows: 1 operation for mapping the node $S$, at most 3 operations for checking the conditions, and 1 operation for sending the packet when a condition is satisfied. Thus, the total computation work needed to forward a message is 5 elementary operations at most.

Algorithm 2 is invoked by the rest of the nodes (transient and destination nodes) in the routing process. The communication overhead for a single node is 1 since it only forwards 1 packet when a certain condition is satisfied. Note that, for a path of length $n$, the source node is not counted since it only performs Algorithm 1. Consequently, the total communication overhead is $n-1$. The local computation of Algorithm 2 for a single node is based on at most 12 operations as follows. 5 of them are assignment operations from line 3 to line 10. 7 operations are related to the conditions that check the degree of the current node and to decide in which direction to forward the packet. 1 operation is to send a packet when a certain condition is satisfied. Thus, since the source node is not counted, the local computation for a path of length $n$ is $12(n-1)$

5 Independent Spanning Trees Parallel Construction

In this section, we present parallel algorithms to construct the four independent spanning trees. Based on the partition presented in Section 4, Table 4 shows the parent and children nodes of each node in the first spanning tree. For example, as shown in Figure 3, node $-i\in S_{4}$ has parent node $-2i$ through the edge $-i$ and has no child. Furthermore, node $-1+i\in R_{2}$ has parent node $-1+2i$ through $+i$ edge and has child nodes $i$ and $-1$ through $+1$ and $-i$ edges, respectively.

In order to get the tables related to the other trees ($T^{(2)}_{k}$, $T^{(3)}_{k}$, $T^{(4)}_{k}$), we define a $90^{o}$ counterclockwise rotation mapping $\sigma$ on Table 4 as $\sigma$(Table 4) = ($\delta$(Node in), $\rho$(Paernt), $\rho$(Child)). The $\delta$ is a cyclic 5-shift on the "Node in" column and $\rho$ is the previously defined rotation. Let the column "Node in" $=(B_{1},R_{1},Q_{1},P_{1},S_{1},B_{2},R_{2},\dots,P_{4},S_{4})$, the cyclic 5-shift $\delta$ on column "Node in" is $\delta$(Node in) $=(B_{2},R_{2},\dots,P_{4},S_{4},B_{1},R_{1},Q_{1},P_{1},S_{1})$. That is, we move the first 5 entries of the first column to the end of the same column. Thus, the parent and child nodes of each node in trees $T^{(2)}_{k}$, $T^{(3)}_{k}$, and $T^{(4)}_{k}$ are $\sigma$(Table 4), $\sigma^{2}$(Table 4), and $\sigma^{3}$(Table 4), respectively. The $\sigma^{t}$ means that the rotation is applied $t$ times on Table 4.

The following two parallel algorithms constructs the four independent spanning trees. Algorithm 3 triggers the parallel constructions of the trees from root $S$.

In Algorithm 4, we use a static variable as per the C programming language semantics. We assume that each node invokes Algorithm 4 as an independent local function. A static variable is declared and initialized only once at the local function first invocation. Its lifetime extends till the global termination of the parallel construction, and it preserves its value between different invocations. Using a static variable enables deciding whether a node has been visited or not as in Algorithm 4, steps 1 to 5. If the node has been already visited, the current node simply ignore the received packet. Otherwise, the current node computes its relative address based on the received packet (addr). Then, it matches its relative address with the entries of Table 4 and $\sigma^{t}$(Table 4), for $t=1,2,3$, to determine the edge directions of its parents and children in all spanning trees. After that, it forwards the received packet (addr) to all its neighbor nodes except the one it has already received it from.

We will derive the algorithms’ number of steps assuming that each node can simultaneously send and receive on all its edges. If the network is fault-free, the algorithms construct the four trees in $k+1$ steps. This follows from the facts that the trees construction propagates in all directions and the network diameter is $k$. Thus, each node is reached in at most $k$ steps. The nodes that receive the packet in the $k^{th}$ step will forward it to their neighbors, and this constitutes the one extra step.

If there are one to three node failures, the algorithms construct at least one fault-free path between each node in the network and the root node. In this case, however, the trees are not necessarily constructed as a faulty node could split a spanning tree into two subgraphs. The construction is bounded by $2k+1$ steps. The trees construction propagates in all directions, and hence each tree structure is traced. By Lemma 3.5, each tree height is $2k$. Thus, each node will be reached through at least one tree in at most $2k$ steps. The nodes that receive the packet in the $2k^{th}$ step will forward it to their neighbors, and this adds the one extra step.

The total messages generated by the construction algorithms is $6k^{2}+6k+4$ as each node generates three messages except the root node generates four.

Algorithm 3 runs in the root node only. Its local computation is limited to 5 operations as follows: one operation to assign the $addr$ variable and 4 operations to send a message to all neighbor nodes. Except the root node, all network nodes execute Algorithm 4 whose local computations is around 15 operations. Thus, the total amount of computation work is $15(2k^{2}+2k)+5=30k^{2}+30k+5$.

6 Simulation

This section discusses the simulation results of our study. We analyzed the construction of independent spanning trees based on the following cases: No faulty node, 1 faulty node, 2 faulty nodes, and 3 faulty nodes in the network. We assumed that each node can simultaneously send and receive to all its neighbor nodes. We have simulated all possible faulty node combinations and measured the average of all maximum steps to construct the trees or paths in different networks as shown in Table 5 and Figure 8. We also measured the maximum of all maximums as displayed in Table 6.

The simulation results are consistent with the bounds we derived in the previous section.

7 Conclusions

In this paper, we presented constructions of four symmetric node independent spanning trees in Gaussian networks, and proved their height is $2k$. Using these trees, we designed routing algorithms that can be used in fault-tolerant and/or secure message communication applications. We also presented fault-tolerant parallel construction algorithms for the presented trees. These algorithms require $k+1$ steps if the network is fault-free and $2k+1$ steps if one to three faulty nodes exist. The total communication overhead of these algorithms is $6k^{2}+6k+4$, and the total amount of computation work is $30k^{2}+30k+5$. We simulated the constructions of the trees in fault-free and faulty networks. The simulation analysis is consistent with our theoretical analysis.

In future research we plan to investigate the constructions of completely independent spanning trees in Gaussian networks and similar regular topology.