Cluster-Fault Tolerant Routing in a Torus.

The number of Internet-connected devices grows very rapidly, with even fears of running out of available IP addresses. It is clear that the number of sensors follows this trend, thus inducing large sensor networks. It is insightful to make the comparison with the huge number of processors of modern supercomputers. In such large networks, the problem of node faults necessarily arises, with faults often happening in clusters. The tolerance to faults, and especially cluster faults, is thus critical. Furthermore, thanks to its advantageous topological properties, the torus interconnection network has been adopted by the major supercomputer manufacturers of the recent years, thus proving its applicability. Acknowledging and embracing these two technological and industrial aspects, we propose in this paper a node-to-node routing algorithm in an n-dimensional k-ary torus that is tolerant to faults. Not only is this algorithm tolerant to faulty nodes, it also tolerates faulty node clusters. The described algorithm selects a fault-free path of length at most n ( 2 k + ⌊ k / 2 ⌋ - 2 ) with an O ( n 2 k 2 | F | ) worst-case time complexity with F the set of faulty nodes induced by the faulty clusters.

1. Introduction

As mentioned, for instance, in [1,2], the number of Internet-connected devices is seeing a very rapid growth, with even fears of running out of available IP addresses. It is clear that the number of sensors follows this trend, thus inducing large sensor networks. The interconnection issue of sensor networks is thus critical. Given the large number of sensors involved, it is critical that these interconnection networks come with efficient data communication algorithms to maximise the performance of the sensor network. Because hardware failure is highly probable given the scale of the network, the tolerance to faults by such routing algorithms is key to data communication efficiency and robustness.

Considering the number of network nodes involved, it is insightful to make the comparison with the number of processors of modern supercomputers. In such large networks of processors or sensors, the problem of faulty nodes necessarily arises, with faults often happening in clusters. The tolerance to faults, and especially cluster faults, is thus critical as detailed below. Featuring advantageous topological properties, the torus network [3] has become very popular as interconnection network of supercomputers (e.g., IBM Blue Gene/L and Blue Gene/P, Cray Titan (Gemini interconnect [4]) and Fujitsu K (Tofu interconnect [5])) [6], thus proving the applicability of the torus topology for large network interconnection. Such topological properties of an n-dimensional k-ary torus include the network degree , the diameter and the network order (i.e., number of nodes) . This is to be compared with, for instance, the hypercube network [7] (n-cube) that was favoured for earlier supercomputers (e.g., the Cosmic cube [8]), of degree and diameter n and network order . So, given the physical restrictions on the number of links per node, that is, on the network degree, a torus is able to connect far more nodes than a hypercube: a small dimension n keeps the degree low, while its arity k can be adjusted to fit the number of nodes. The formal definition of a torus is given in the next section. Tori are also used for hierarchical interconnection networks [9].

From Menger’s theorem [10], node-to-node routing can tolerate at most faulty nodes, with d the network degree. By considering a special class of network, here tori, we show that more faults can be tolerated for such a routing scenario. More precisely, in this paper we describe a node-to-node torus routing algorithm under the cluster-fault tolerant model: in addition to faulty nodes, faulty clusters of diameter at most one are considered. This furthermore induces new conditions on the number of tolerable faults in such a network, thus refining the conditions stated by Menger’s theorem. And thanks to this cluster-fault tolerant approach, the proposed algorithm is also tolerant to edge faults: given a faulty edge , it suffices to declare the two nodes u, v as one faulty cluster.

Given the number of nodes and edges involved in an n-dimensional k-ary torus, solving this cluster-fault tolerant routing problem with a conventional routing algorithm such as Dijkstra’s is clearly impractical: its worst-case time complexity is of polynomial order in the number of nodes or edges of the network, and the same discussion holds with a breadth-first search algorithm [11]. It is thus an effective, and as shown in Section 2 a commonly relied upon approach to describe a routing algorithm for a specific class of graph, here a torus, to provide a practical solution to this routing problem.

As recalled earlier, large sensor networks are nowadays common, and they include thousands of network nodes (i.e., sensor nodes). Fault-tolerance (resilience) and scalability are two key requirements of such networks [12]. This research on the torus interconnection network brings a concrete solution to these issues as detailed below. Indeed, we can rely on the torus network topology to interconnect the sensors, which are themselves attached to “things” of the Internet of things (IoT). In this situation, we assume that these things are static, that is, not moving. In order to report the data collected across the sensor network by each sensor on its thing to the requesting device (the user) which is connected via the Internet to one network node (the sink), the data are delivered through the torus to the requester by forwarding the data according to the paths calculated by the proposed algorithm, paths which connect each sensor node to the (current) network sink.

First, from its definition, and precisely the node degree that does not depend on the network arity, the torus topology provides a high scalability, for instance when compared to other network topologies such as hypercubes [7] and star graphs [13]. Second, considering the large number of sensors involved, faulty sensors are unavoidable. Besides, it is usually expected that the sensor faults take place in a cluster rather than occurring independently. By describing a routing algorithm that is tolerant to faults, the resilience and data transmission performance of the sensor network are increased, which thus offers a higher quality-of-service. Third, with such a connection approach, a distributed sensor network can be easily realised: as mentioned above, a master device accesses the sensor network from the Internet, which further increases the network resilience as none of its nodes has special powers.

In addition to increasing the fault tolerance of data transfers and thus of the whole network, it is important to consider the cluster-fault tolerant model given hardware technical properties of the machinery: it is indeed not rare that faults in such a system occur in clusters. For example, one same electrical unit supplies power to a few nodes. When this power unit fails—battery lifetime is a notorious issue of sensor nodes [14]—the corresponding nodes induce a faulty cluster. As another example, several nodes can be managed by one same hosting or controlling device, like two IoT things which depend on one controlling unit, or a blade inside a cabinet of a supercomputer. Failure of the hosting device would similarly result in a faulty cluster.

Smart agriculture is one application field of our research results. For example, in south-east Asian countries paddy fields are popular for the culture of rice. Such paddy fields are wide areas immersed in water (see Figure 1a). The implementation of smart agriculture without interfering with the automated farm operations, a wireless sensor network is suitable to collect information about the paddy field. Sensors in the field are positioned according to the points of a two-dimensional lattice and each sensor has a transmission range so that it can at least communicate with its four neighbour sensors. In addition, the wrap-around edges that connect the sensors placed on the periphery of the paddy field are implemented with wires. Consequently, the sensor network forms a two-dimensional torus structure (see Figure 1b).

Figure 1

(a) A paddy field with young crops. (b) A sensor network for a paddy field where the small circles represent sensors. The orange disc represents the transmission range of the sensor at its centre. The wireless and wired interconnection network forms a two-dimensional torus structure.

Another example with respect to smart agriculture is a plant factory [15,16]. In such a facility, plant pods are organised in a three-dimensional manner and cultivated under optimal growth conditions. In this situation as well, a wireless sensor network is suitable to not interfere with the factory automated operations. Precisely, in the factory the sensors are positioned according to the points of a three-dimensional lattice and each sensor has a transmission range so that it can at least communicate with its six neighbour sensors. In addition, on the floor, walls and ceiling, the wrap-around edges are implemented with wires. As a result, the sensor network forms a three-dimensional torus structure.

The rest of this paper is organised as follows. Previous and related works are discussed in Section 2. Graph notations and definitions together with lemmas and propositions are recalled and established in Section 3. The proposed algorithm is described and exemplified in Section 4. The algorithm correctness is formally established in Section 5; this is a major part of the paper. Complexity analysis, precisely the maximum path length and worst-case time complexity, is formally conducted in Section 6 to evaluate the theoretical performance of the algorithm, and from which the main theorem of this research is induced. Then, in Section 7, the algorithm performance in average is empirically evaluated with computer experimentations and compared to the theoretical values. Finally, this paper is concluded in Section 8.

2. Previous and Related Works

The torus topology is often presented as an extension of the mesh network [3] to which “wrap-around edges” have been added and it has been itself further extended [17], for instance to design a hierarchical interconnection network [9].

There exist a few routing algorithms that are tolerant to faults which have been described for a torus network. Torus fault-tolerant routing algorithms based on the simple node-fault tolerant model (i.e., not considering faulty clusters) have been described in [18] with a node-to-node and a node-to-set disjoint paths routing algorithm. In an n-dimensional k-ary torus (, ), the former algorithm selects a fault-free path of length at most in time with a fault tolerance of at most faulty nodes while the latter algorithm selects f () fault-free paths of lengths at most in time with a fault tolerance of at most faulty nodes. Still based on the simple node-fault tolerant model, an adaptive node-to-node routing algorithm for a 2-dimensional torus has been given in [19].

Other routing algorithms that apply to a torus network have been proposed. A torus set-to-set disjoint paths routing algorithm has been described in [20]. In an n-dimensional k-ary torus (, ), this algorithm selects mutually node-disjoint paths between source nodes and destination nodes, without imposing a particular pairing. The paths are selected in time and have lengths that are at most . Then, a torus pairwise disjoint paths routing algorithm has been presented in [21]. In an n-dimensional k-ary torus (, ), given c () source–destination node pairs, this algorithm finds c mutually node-disjoint paths that connect the nodes of the c pairs. The paths are selected in time and have lengths at most .

In other networks, fault-tolerance under the simple node-fault tolerant model has been treated, for instance, in hypercubes with a unicast algorithm [22] and a set-to-set disjoint paths routing algorithm [23], in star graphs with a set-to-set disjoint paths routing algorithm [24] and in burnt pancake graphs with a unicast algorithm [25]. Furthermore, fault-tolerant routing with an additional constraint regarding the nodes that can be selected has been discussed, for instance, in hypercubes [26]. Finally, routing algorithms based on the cluster-fault tolerant model have been proposed for burnt pancake graphs with a unicast algorithm [27], hypercubes with a unicast algorithm [28], a node-to-set and set-to-set disjoint paths routing algorithm [29] and a pairwise disjoint paths routing algorithm [30], and star graphs with a unicast algorithm [31] and a node-to-set and pairwise disjoint paths routing algorithm [32], amongst others.

3. Preliminaries

First, general graph theory notations and definitions are recalled—the notations and definitions that are not mentioned here are in accordance with [33].

Graphs herein are undirected. For a node u in a graph G, let be the set of the nodes adjacent to u in G. A path in a graph G is a connected acyclic sub-graph of G of maximum degree 2. From this definition, a path necessarily has either one or two nodes of degree at most 1; they are called the end nodes of the path. For the sake of readability, a path is simply denoted by a sequence of nodes and edges as follows: , and is further abbreviated to when non-ambiguous. The node set that includes the nodes of a path p is simply denoted by p when non-ambiguous. Two paths are mutually node-disjoint (or simply “disjoint”) if and only if . When the path intersection consists solely of end nodes, the two paths are said to be internally disjoint. A path is fault-free if and only if it does not include a faulty node. A path is blocked if it includes at least one faulty node. The length of a path is its number of edges.

An n-dimensional k-ary torus

A 2-dimensional 3-ary torus and a 3-dimensional 3-ary torus are illustrated in Figure 2a,c, respectively.

Figure 2

(a) A 2-dimensional 3-ary torus . (b) Illustration of the recursive structure of a torus: a consists in three 1-dimensional 3-ary sub-tori . (c) A 3-dimensional 3-ary torus .

For a node

In this research, we consider faulty clusters that include at most two nodes. So, a cluster is formally defined as follows.

A cluster c of a graph G is a connected subgraph of G that is isomorphic either to a

For a graph G and a cluster set C, the set

Next, several torus properties are recalled. First, a torus has a recursive structure; this is Proposition 1 below.

Considering a dimension δ (

The three sub-tori , and of a induced by are shown in Figure 2b.

For a node

For a node

Second, there exist disjoint paths between sub-tori.

For a node

A constructive proof is given. For the node set , define the path set . The paths in are internally disjoint by Definition 2. □

For a node

A constructive proof is given. For the node set , define a set of path variants with respect to the path set as . Further define the bijection that associates each of the paths of to the path of () and the unique path of to the path of . The paths in are internally disjoint for any subset with by Definition 2. □

For a node

A constructive proof is given. For the node set and the path set , define the path set . □

For a node

The paths of , , and are illustrated in the case of a in Figure 3.

Figure 3

Illustrating the paths of , , and in the case of a .

4. Cluster-Fault Tolerant Routing Algorithm

Inside an n-dimensional k-ary torus that includes a set C of at most faulty clusters (which induce the set of faulty nodes F), we describe a routing algorithm that selects a fault-free path between any two nodes with .

4.1. Algorithm Description

First, we present the assumptions made and the main idea of the proposed routing algorithm. A is isomorphic to a ring, and it is thus trivial to find a fault-free path between any two non-faulty nodes given that there is at most faulty cluster. So, we can assume that .

A has one single node and thus it is trivial to find a fault-free path (). It is easy to show that this problem is not solvable when : see Figure 4. Hence, a torus arity is considered hereinafter.

Figure 4

Unsolvable problem instances in the case (a), (b) and (c), within a with two clusters, a with five clusters and a (some nodes are omitted for clarity) with five clusters, respectively. Faulty nodes are greyed and the clusters that include two nodes are materialised with thicker lines.

The main idea of this algorithm is to follow a divide-and-conquer approach by routing s to a node of and to apply this algorithm recursively in . Consider an arbitrary dimension (). We distinguish the following mutually exclusive cases.

(base case) is fault-free (i.e., ):

This is simple point-to-point routing. A path between s and d is selected with a dimension-order routing algorithm [3].

(special case) unavailable (i.e., ):

unavailable (i.e., ):

We can apply the algorithm recursively in neither nor , so we use another sub-torus. Route s and d to an available sub-torus , that is satisfying , with a fault-free path of and a fault-free path of , respectively.

Let (resp. ) be the selected path that connects s (resp. d) to a node of . If these paths are not disjoint, consider the node that is the closest to s, discard the sub-paths and and terminate. Otherwise, apply this algorithm recursively in with as source node, as destination node and as cluster set.

available (i.e., ):

Exchange the roles of s and d; this is Case 2.

available (i.e., ):

Define the set of paths from s to a node of .

(special case) s not routable to (i.e., ):

Route s and d to an available sub-torus , that is satisfying , other than with a fault-free path of and a fault-free path of , respectively.

Let (resp. ) be the selected path that connects s (resp. d) to a node of . If these paths are not disjoint, consider the node that is the closest to s, discard the sub-paths and and terminate. Otherwise, apply this algorithm recursively in with as source node, as destination node and as cluster set.

(general case) s routable to (i.e., , ):

Route s to with a fault-free path of Q. Let be the selected path of Q that connects s to a node of . If (i.e., ), terminate. Otherwise, apply this algorithm recursively in with as source node, d as destination node and as cluster set.

4.2. Routing Example in a

We give a non-trivial example of execution trace for the proposed routing algorithm. Let , and be the source node, destination node and cluster set in a , respectively. Furthermore, is arbitrarily initialised to 3. The execution trace of the algorithm is given in Table 1. The leftmost column indicates the iteration step, and the “Sub-Torus” column the sub-torus selected for recursion. It is recalled that the torus arity (here, ) is constant throughout the execution of the algorithm; it is thus not repeated in the table. The first iteration step falls in Case 2.1, the second in Case 2.2 and the third in Case 0 of the algorithm.

Table 1

A sample execution trace of the algorithm for a non-trivial routing example in a .

⥀	δ	n	s	d	C	Sub-Torus	Selected Paths
1	3	3	(1,1,0)	(1,0,1)	{{(1,1,1),(0,1,1)},{ (0, 1, 0) },{ (1, 0, 0) },{ (2, 1, 0) },{ (1, 2, 0), (1, 2, 4) } }	T^4,3(2,5)	s=(1,1,0)→(1,1,4)=s^′ d=(1,0,1)→(1,0,2)→(1,0,3)→(1,0,4)=d^′
2	2	2	(1,1,4)	(1,0,4)	{{(1,2,4)}}	T^0,2(1,5)	s=(1,1,4)→(1,0,4)=s^′
3	-	1	(1,0,4)	(1,0,4)	∅	-	s=(1,0,4)=d
Output: s=(1,1,0)→(1,1,4)→(1,0,4)→(1,0,3)→(1,0,2)→(1,0,1)=d

5. Proof of Correctness

In this section, the correctness of the proposed algorithm is established. Each of all the distinguished cases is treated separately.

5.1. Case 0

There is no faulty node inside , so a dimension-order routing algorithm can be applied.

5.2. Case 1.1

The sub-tori and each include at least clusters (possibly partially, i.e., ) and are thus unavailable in order to solve the problem recursively. Here are two necessary conditions for this situation to occur: 1) is adjacent to (i.e., ) and 2) out of the at most clusters, at least of them have two nodes, with one node in and the other in .

First, we show that there exist at least three sub-tori that are available for recursion, that is, that include at most clusters. It is recalled that both and are not. At least clusters are included (completely contained) in . Hence, for both and to satisfy , there remains at most two faulty nodes that are included in other sub-tori (i.e., neither in nor ). These two faulty nodes are either part of the same cluster, or, they are part of two distinct 2-node clusters that have one node in and one node in , respectively. So, importantly, if these at most two faulty nodes are part of two distinct 2-node clusters, these two faulty nodes are necessarily located in different sub-tori. See Figure 5.

Figure 5

The two possible cluster repartitions in Case 1.1 with respect to and when and thus at most five clusters. Ellipses separate sub-tori.

To apply the algorithm recursively inside a sub-torus, it can include at most clusters. So, one sub-torus can be made unavailable with at least clusters. Therefore, either the at most one 2-node cluster or the at most two faulty nodes located in distinct sub-tori suffice not to make another sub-torus unavailable for recursion since they would induce at most one cluster inside a sub-torus, and given that . Therefore, since there exist at least sub-tori and at most two of them are unavailable ( and ), at least three sub-tori always remain available for recursion.

Next, we show that both s and d are routable to at least one of these three available sub-tori. If s and d are adjacent, select and there is nothing else to prove. So, we can assume that s and d are not adjacent. We distinguish the following mutually exclusive sub-cases which are exhaustive.

Sub-case This case can occur only when and it implies that either (a) there are two 2-node clusters each included in , or (b) there is only one such cluster and the other two clusters respectively have at least one node in and one node in . As shown in Figure 6, the former case (a) occurs only when and the latter case (b) only when . Hence, given that is assumed, these two cases shall never occur and there is thus nothing to prove.

Figure 6

The two situations for Case 1.1’s sub-case . (a) required; (b) required. Ellipses separate sub-tori, faulty nodes are greyed and the clusters that include two nodes are materialised with thicker lines.

Sub-case Since both and unavailable, at least clusters each have one node in and the other in , and either (a) at least one other cluster also has, or (b) the two other clusters each have at least one node in . In the former case (a), at least clusters each have one node in and the other in , and those clusters thus can block at most one path of and at most one path of . The remaining cluster, if any (there is at most 1), can either block at most two paths of for at most two available sub-tori, or at most two paths of for at most two available sub-tori. Since both situations cannot occur at the same time, there always remains at least one available sub-torus to which both s and d are routable. In the latter case (b), clusters cannot block any path of for the same reason, and the other two clusters each have at least one node in , hence they can block at most two paths of for at most one available sub-torus, and at most two paths of for at most one available sub-torus (the blocked at most two sub-tori are necessarily distinct). Therefore, there always remains at least one available sub-torus to which both s and d are routable.

Sub-case This is the same proof as for the previous case (i.e., and ).

5.3. Case 1.2

Case 2 is applied, so refer to the proofs of Cases 2.1 and 2.2.

5.4. Case 2.1

We indeed need to consider the paths of (they are each of length at most k) given that the paths of (they are each of length at most ) may not suffice to route s to another sub-torus as shown in Figure 7a.

Figure 7

Situations of Case 2 in a : (a) the situation in Case 2.2 where the paths of do not suffice to route s to another sub-torus; (b) the situation in Case 2.1 where s is not routable to .

So, s not routable to implies that the paths of are all blocked. This situation occurs only when both 1) at least clusters each have at least one node in , and 2) one of these clusters includes , or there is one other cluster with no node in that does. See Figure 7b.

We show the existence of a sub-torus available for recursion other than . Since at least clusters each including at least one node in , they can induce at most two unavailable sub-tori. If two unavailable sub-tori are so induced, they are and one sub-torus adjacent to (that is not since available by assumption), and the remaining cluster includes and thus suffices not to make one additional sub-torus unavailable. If only one unavailable sub-torus is so induced, it is necessarily since available by assumption, and thus exactly clusters each have at least one node in and the remaining cluster which has no node in includes . Therefore, since there exist at least sub-tori and at most two of them are unavailable (one of which necessarily being ), at least three sub-tori always remain available for recursion.

Next, we show that both s and d are routable to at least one of these three available sub-tori. If s and d are adjacent, select and there is nothing else to prove. So, we can assume that s and d are not adjacent. We distinguish the following mutually exclusive sub-cases which are exhaustive.

Sub-case Exactly clusters thus have at least one node in ( is thus unavailable). These clusters cannot block a path of and can block at most two paths of for at most one available sub-torus. The remaining cluster necessarily includes and can thus block at most two paths of for at most two available sub-tori, one being ; it can block no path of . Therefore, there always remains at least one available sub-torus other than to which both s and d are routable.

Sub-case Since available, . Thus, there exist two non-faulty nodes and . If the remaining cluster (i.e., that includes no node of ) includes , it can block at most two paths of for at most one available sub-torus. If it does not, it can block either: at most two paths of for at most two available sub-tori, or at most two paths of for at most two available sub-tori, or at most two paths of and at most two paths of for at most one available sub-torus. Therefore, there always remains at least one available sub-torus other than to which both s and d are routable.

5.5. Case 2.2

There is nothing to show given that is available for recursion and s is routable to .

6. Complexity Analysis

In this section, we establish the length of a longest path as selected by the proposed algorithm, as well as the worst-case time complexity of this algorithm. It is assumed that the value of each dimension of a node address can be accessed in constant time . Let be the worst-cast time complexity of the algorithm when applied in a with faulty clusters, and let be the maximum length of the generated path.

The path is obtained with a dimension-order routing algorithm. Hence, in a it is of length at most . This algorithm takes time.

It takes time to check if holds.

It takes time to check if holds. An available sub-torus is found when holds and both are routable to it with the defined paths. Checking for one sub-torus candidate for whether holds takes time. The path for one sub-torus candidate for can be found in time since by Lemma 2 and with each path from those tried for being of length at most by Lemma 1. A similar discussion holds for . So, checking if one sub-torus is suitable as takes time. Hence, an available sub-torus can be found in by enumerating the k sub-tori. Checking the intersection of and takes time. If it is not empty, sub-paths are discarded in constant time and the algorithm is terminated. Otherwise, the algorithm is applied recursively in , thus inducing a time complexity and a maximum path length, with (and obviously ). So, in total, this case is time and induces a maximum path length.

The time complexity and maximum path length induced by Case 2 apply.

It is not needed to check again whether is available.

It takes time to check whether s is routable to . An available sub-torus is found when holds and both are routable to it with the defined paths. Checking for one sub-torus candidate for whether holds takes time. The path for one sub-torus candidate for can be found in time since by Lemma 2 and with each path from those tried for being of length at most by Lemma 1. A similar discussion holds for . So, checking if one sub-torus is suitable as takes time. Hence, an available sub-torus can be found in by enumerating the sub-tori ( excluded). Checking the intersection of and takes time. If it is not empty, sub-paths are discarded in constant time and the algorithm is terminated. Otherwise, the algorithm is applied recursively in , thus inducing a time complexity and a maximum path length, with once again . So, in total, this case is time and induces a maximum path length.

The path can be found in time since by Lemma 3 and Definition 7 and with each path from those tried for being of length at most k by Lemma 3. The algorithm is applied recursively in , thus inducing a time complexity and a maximum path length, with once again . So, in total, this case is time and induces a maximum path length.

From this discussion, we can derive the following theorem.

In a

The existence of a fault-free path is shown in Section 4 and Section 5. The complexities are derived from Section 6 which induces the following recursive expressions regarding the time complexity and maximum path length: and with (and obviously ). The relation is the invariant of the recursion. Since n is decreased by one at each step, is guaranteed to reach 0, that is the base case of the recursion. Therefore, the total worst-case time complexity of the proposed algorithm is and the maximum path length is . □

The described algorithm selects a fault-free path of length at most with an worst-case time complexity with F the set of faulty nodes induced by the faulty clusters. The maximum path length is of the same order as the network diameter: , which is thus on par with previous works on node-to-node routing under the cluster-fault tolerant model [27,28,31].

7. Empirical Evaluation

Now that the worst-case complexities have been established in Section 6, we inspect the average behaviour of the proposed algorithm, implemented to this end. Two experiments were conducted: the first one aims at measuring the maximum length of a path selected by the proposed algorithm, and the second one at measuring the average execution time taken by the algorithm to solve one instance of the torus cluster-fault tolerant routing problem. These experiments were conducted on a computer equipped with an Intel Core i5-1035G7 processor (clocked at 1.20 GHz) and 8 GB RAM, and running Windows 10 Home 64-bit.

The experimental conditions for the first experiment (i.e., maximum path length measurement) were as follows: in a , the source node and destination nodes are randomly selected in the set of all the torus nodes. The torus arity k was fixed to 5 in this experiment to maximize the routing difficulty as indeed the number of faults depends on n and not on k. Then, the maximum number of faulty clusters that can be tolerated were also randomly generated. The faulty clusters are all of diameter one to once again maximize the routing problem difficulty (i.e., a higher number of faulty nodes). Then, the algorithm implementation was used to solve the corresponding routing problem and the length of the selected path output was recorded. This process was repeated 10,000 times for each value of n with , each time calculating two path length values: the maximum path length and the average path length of the 10,000 selected paths. The results of this first experiment are shown in Figure 8, together with the theoretical maximum path length as established previously in Section 6 for reference.

Figure 8

Empirical evaluation: average and maximum (with standard deviation) path lengths of the paths selected by the proposed algorithm in a .

The second experiment (i.e., execution time measurement) was conducted in the same experimental conditions as the first experiment at the exception that the routing problem was solved in a : the arity k was set to in this time experiment to evaluate the average time complexity as k and n both increase. The path selection algorithm was run 10,000 times for each pair with , each time measuring the real CPU time (i.e., excluding the time for garbage collection) taken to solve the problem instance. The obtained results are given in Figure 9, together with the worst-case time complexity as established previously in Section 6 for reference.

Figure 9

Empirical evaluation: average execution time to solve one problem instance with the proposed algorithm in a .

The following observations can be made from the obtained experimental results. First, regarding the maximum path length, one can note that it remains at distance from the theoretical upper bound, which is an indicator of the good performance of the algorithm. Second, regarding the average execution time, one can note that it remains well below the worst-case time complexity, which is yet another indicator of the efficiency of the proposed algorithm.

8. Conclusions

The growing number of Internet-connected devices and their sensors, comparable to that of computing nodes included in modern supercomputers, induces large interconnection networks. Hence, the performance of networks on this scale is tied to efficient and robust data routing. For example, major supercomputer makers such as IBM, Cray and Fujitsu have been relying on the torus topology for the interconnection network for its advantageous topological properties. The torus topology is also applicable to interconnect sensor networks, for instance, to report information collected by sensors across the network to the network user. Given the huge number of network nodes involved, faults are very likely to occur. A routing algorithm in a torus that is tolerant to faults is thus key for the future of such networks and has direct implications to the quality-of-service issue by reducing the number of failed data communications. Furthermore, hardware technical properties inducing that faults often happen in clusters (e.g., a same power supply unit applies to a few nodes), it is critical to not only tolerate node faults but also cluster-faults. Improving on Menger’s condition on the maximum number of node faults that can be tolerated, and on torus fault-tolerant routing algorithms described in previous works, we have proposed in this paper for the first time a node-to-node routing algorithm in a torus that is tolerant to cluster-faults. In a with at most faulty clusters of diameter at most 1, the described algorithm selects a fault-free path of length at most with an worst-case time complexity with F the set of faulty nodes induced by the faulty clusters.

Regarding future works, it will be meaningful to first try to consider faulty clusters of diameter 2, possibly reducing the number of tolerated faulty clusters. Then, selecting several fault-free disjoint paths between the source and destination nodes can be considered. Furthermore, measuring the average performance of the proposed algorithm and comparing the results with the formally established worst-case complexities (maximum path length and time complexity) is yet another research route.