Torus Pairwise Disjoint-Path Routing.

Modern supercomputers include hundreds of thousands of processors and they are thus massively parallel systems. The interconnection network of a system is in charge of mutually connecting these processors. Recently, the torus has become a very popular interconnection network topology. For example, the Fujitsu K, IBM Blue Gene/L, IBM Blue Gene/P, and Cray Titan supercomputers all rely on this topology. The pairwise disjoint-path routing problem in a torus network is addressed in this paper. This fundamental problem consists of the selection of mutually vertex disjoint paths between given vertex pairs. Proposing a solution to this problem has critical implications, such as increased system dependability and more efficient data transfers, and provides concrete implementation of green and sustainable computing as well as security, privacy, and trust, for instance, for the Internet of Things (IoT). Then, the correctness and complexities of the proposed routing algorithm are formally established. Precisely, in an n-dimensional k-ary torus ( n < k , k ≥ 5 ), the proposed algorithm connects c ( c ≤ n ) vertex pairs with mutually vertex-disjoint paths of lengths at most 2 k ( c - 1 ) + n ⌊ k / 2 ⌋ , and the worst-case time complexity of the algorithm is O ( n c 4 ) . Finally, empirical evaluation of the proposed algorithm is conducted in order to inspect its practical behavior.

1. Introduction

Since the development of parallel supercomputers, the number of included processors has been continuously rising. The hardware component that is responsible for the connection of processors is the interconnection network (a.k.a., interconnect). Hypercubes [1] were a popular topology for the interconnection network of massively parallel systems in the eighties. Intel developed, for instance, the iPSC supercomputer series, with the iPSC/1 device connecting 32 to 128 cores: the iPSC/d5 is based on a five-dimensional hypercube, hence connecting cores; the iPSC/6 is based on a six-dimensional hypercube, hence connecting 64 cores, and the iPSC/d7 128 cores. A similar approach was followed by the nCUBE company that built, for example, the nCUBE 10 device, which is based on a 10-dimensional hypercube, hence connecting 1024 cores.

Nowadays, machines of the megaFLOPs era, such as the nCUBE, have been replaced by ones featuring a computing power of several petaFLOPs, and with even the exaFLOP barrier possibly being reached as soon as 2020 by the Cray company [2]. Regarding the number of processors embodied, modern massively parallel systems rely on hundreds of thousands of them. One step ahead, the Sunway TaihuLight supercomputer, ranked world number one in June 2017 and second as of June 2018 [3], includes more than one million cores. Considering this very large number of processors, it is easy to understand that data communication efficiency and interconnection networks in general are critical to achieving the highest computing performance. Indeed, in the case of suboptimal core interconnection and data transfers, bottleneck situations would inevitably arise, inducing underused cores.

Just as complete networks are not practical as interconnection networks of massively parallel systems given the prohibitively high number of edges per processor induced, hypercubes are no more a solution considering the number of nodes involved. Precisely, the vertex degree in the case of a hypercube becomes rapidly impractical as n edges per vertex are required for the hypercube to connect, in total, vertices. As a result, various topologies designed for interconnection networks have been introduced. For example, Li et al. proposed the dual-cube [4] and metacube [5] topologies, both based on hypercubes. The star-graph [6] is another topology example, this time based on permutations, which was used to introduce other topologies, such as burnt pancake graphs [7].

Topologies based on meshes [8] are another solution for interconnection networks. One of these, the torus topology [9], is addressed in this paper. Thanks to a simple definition and an advantageous network order compared with, for instance, hypercubes, the torus network topology is very popular as interconnect of supercomputers. Indeed, numerous machines listed in the TOP500 world ranking are based on the torus topology. For example, the Fujitsu K (Tofu interconnect [10,11]), IBM Blue Gene/L, IBM Blue Gene/P, and Cray Titan (Gemini interconnect [12]) supercomputers [3]. The main topological properties of tori and those of various other interconnection networks are given in Table 1. In this table, the network cost is the product of network degree by network diameter.

Table 1

Comparing torus topological properties with other popular interconnection networks [9].

Network	Order	Degree	Diameter	Cost	Links
(n, k)-torus	k^n	2n	n⌊k/2⌋	2n^2⌊k/2⌋	nk^n
n-hypercube	2^n	n	n	n^2	2^nn
n-dual-cube	2^2n−1	n	2n	2n^2	2^2n−2n
n-star graph	n!	n−1	⌊3(n−1)/2⌋	(n−1)⌊3(n−1)/2⌋	n!(n−1)/2
(k, m)-metacube	2^2^km+k	m+k	2^k(m+1)	2^k(m+1)(m+k)	2^2^km+k−1(m+k)

In this paper, the torus pairwise disjoint-path routing problem is addressed. This critical data communication problem consists of the selection of mutually vertex-disjoint paths between several vertex pairs. As detailed next, this problem has numerous applications. Disjoint-path routing in general is a very desirable property for routing algorithms, and this is for several reasons. First, disjoint-path routing enables simultaneous data transfers over the network, and for that, without the need to change switching patterns inside routers, on the one hand optimizing data transfer performance, and, on the other hand, reducing network usage time. While the former consequence has obvious positive implications, the latter thus induces concrete implementation of energy-harvesting communications and networks, which contents green and sustainable computing [13,14], with applications, for instance, to the Internet of Things (IoT) and cyber–physical systems. In addition, path disjointness enforced at the hardware level with circuit switching means that an optimum degree of privacy is achieved as a data transfer is never interrupted by another transmission. This research thus directly addresses the issues of security, privacy, and trust for the IoT. Second, disjoint-path routing importantly ensures that the notorious blocking situations of parallel processing, deadlocks, livelocks and starvations, never occur, thus facilitating, for instance, distributed data processing in sensor applications. Third, not only efficiency but, by selecting disjoint paths, system dependability is also significantly increased. Effectively, where multiple nondisjoint paths could be rendered useless by a single faulty vertex (i.e., the faulty vertex is common to several paths), disjoint paths are much more robust: one faulty vertex can jeopardize, at most, one path, since any vertex of the network is included in at most one of the selected paths. Such robustness has positive implications regarding, for instance, the quality of experience and service in the IoT and cyber–physical systems.

In an arbitrary c-connected graph , the existence of c disjoint paths for each of the node-to-node disjoint paths, the node-to-set disjoint paths, and the set-to-set disjoint paths problems are ensured by Menger’s theorem [15]. In fact, disjoint paths can be obtained by applying the maximum-flow algorithm assigning unit capacity to each of the edges and the vertices. For c pairs of vertices in arbitrary graph , the problem whether there are c disjoint paths between the c pairs is NP complete if c is a variable of the problem input [16]. For any fixed c, the problem can be solved in [17] though it is still a hard problem.

Due to higher complexity, the pairwise disjoint-path routing problem is typically addressed last after introducing algorithms that solve the unicast (a.k.a., point-to-point, one-to-one, or node-to-node), node-to-node disjoint-path, node-to-set disjoint-path and set-to-set disjoint-path routing problems. In an n-dimensional k-ary torus, a node-to-node routing algorithm has been described in Reference [18] and with fault tolerance in Reference [19], the latter selecting paths of lengths at most , with a worst-case time complexity of . A node-to-set disjoint-path routing algorithm in a torus has also been described in Reference [19], with paths of lengths at most , and a worst-case time complexity of . A torus set-to-set disjoint-path routing algorithm has been given in Reference [20], with paths of lengths at most , and a worst-case time complexity of .

As for different topologies, Gu and Peng described a pairwise disjoint-path routing algorithm in a hypercube [21] and in a star-graph [22]. Bossard and Kaneko solved the same problem in perfect hierarchical hypercubes [23], as did Sawada et al. in pancake graphs [24], and Park focused on restricted hypercube-like graphs [25]. The approach in this paper to select mutually vertex-disjoint paths is, as used in several previous works, to rely on the recursive structure of a torus. Precisely, in an n-dimensional k-ary torus, given c () vertex pairs, the algorithm proposed here selects c mutually vertex-disjoint paths of lengths at most with a worst-case time complexity of .

Related research on disjoint-path routing can be found in Reference [26] where it is applied to data-center networks. Close to disjoint-path routing, independent spanning tree construction has been researched, for instance, in Möbius cubes in [27]. Other related works include the calculation of various topological values of the network topology, such as topological indices [28] and the least eigenvalue [29].

The rest of this paper is organized as follows. Definitions, notations and intermediary results are established in Section 2. The proposed routing algorithm is described in Section 3 and exemplified in Section 4. The proof of the algorithm correctness, including the fact that the selected paths are disjoint, is given in Section 5, which relies on lemmas proved in Section 2. Complexities are formally established in Section 6 and the proposed algorithm is empirically verified and evaluated in Section 7. Finally, this paper is concluded in Section 8.

2. Preliminaries

For the sake of clarity, a vertex pair (in this paper, typically a source-destination vertex pair), denoted by , can be considered as the set . For vertex u, define set as the set of the neighbor vertices of u.

In a graph, a path p is an alternate sequence of vertices and links . Path p can be similarly written as and abbreviated as when explicit mention of the vertices between and is not required. The length of a path is defined as its number of links, hence p has length . Two paths are mutually vertex-disjoint (simply disjoint hereinafter) if and only if they have no vertex in common.

An n-dimensional k-ary torus, denoted by (n, k)-torus, is an undirected graph made of the

Thus, a vertex of an (n, k)-torus is an n-dimensional vector. Therefore, two vertices of an (n, k)-torus can be compared (i.e., equality testing) in linear time, by simply going through each of all the n coordinates of the two vertices. A (2, 4)-torus is illustrated in Figure 1.

Figure 1

A two-dimensional four-ary torus, with vertex addresses in the top right-hand corner of each vertex [9].

An (n, k)-torus is a recursive topology: for one dimension (), it consists of k (, k)-tori (called subtori). For instance, considering the horizontal dimension of the (2, 4)-torus of Figure 1, that is the dimension , this torus consists of four (1, 4)-tori: these subtori appear vertically in the figure. It is said that a path goes through a subtorus T if and only if it includes a vertex of T.

Next, operator is defined for convenient vertex coordinate manipulation. In an (n, k)-torus, for a vertex and a dimension (), let denote the coordinate of vertex u. For instance, . This definition is extended to subtori: let denote the coordinate of subtorus T. For instance, considering the torus of Figure 1 and the dimension , we have where T is the leftmost subtorus (i.e., T consists of the vertices , , and ). Therefore, for dimension , a subtorus T can be unambiguously specified by the value of .

Then, still considering vertex u and dimension , candidate paths and the corresponding path sets for traversing the dimension are defined as follows. Note that these paths specify how to traverse a dimension, thus remaining “open” (i.e., with a start vertex, but no end vertex) for the sake of simplicity.

Given two vertices

n unit vectors

First, define the path: which can be similarly written as

Next, define the two path sets: and

Path and path sets , are defined similarly but with instead of (details in the appendix). In other words, path (resp. ) makes no detour when traversing dimension , while the paths of and (resp. and ) make a detour of one and two links, respectively.

Finally, define the two path sets: and

The paths of and in the case of a (3, 5)-torus are illustrated in Figure 2, where is the dimension used to distinguish subtori.

Figure 2

Considered paths (represented by arrows) for traversing the subtori of a (3, 5)-torus from the vertex u. (a) , , (b) , and (c) , .

For the sake of conciseness, for torus vertex u and dimension , paths and , as well as path sets , , and are abbreviated to , and , respectively, when no ambiguity arises.

Next, a torus point-to-point routing algorithm is recalled. Unicast routing in a torus can be achieved simply with a dimension-order routing algorithm. A dimension-order routing algorithm for packet forwarding in two dimensional meshes is presented by Duato et al. [8]. It can be easily adjusted for routing in an n-dimensional torus as listed in Algorithm 1. The maximum length of a path selected by this algorithm between any two vertices is thus .

To conclude this section, we introduce two essential lemmas on which the algorithm proposed in this paper is based (Section 3).

In an (n, k)-torus (

First, assume without loss of generality that is to be routed to T, and that . The same discussion holds for and for the case . We show that there always remains at least one path of that is not blocked by another source vertex, destination vertex or their respective paths towards T.

First, the paths of consist of shortest path , and of the two sets and . The paths of these two sets are not disjoint: a neighbor u of is included in one single path of each of the two path sets. Hence, if (), two candidate paths are blocked by one single vertex (). The reason for considering and paths is that vertex can indirectly block a candidate path for . Effectively, may trigger the selection of a non-shortest path for a vertex towards T (), and thus in total and each block one path for . See Figure 3.

Figure 3

Vertex can be indirectly a blocker for vertex (selected paths in blue) [9].

Vertex on its own is not a blocker for . Thus, we consider the case where is an indirect blocker through vertex say .

So, by considering the paths of and , we ensure that either there remains one of the two paths, and that is not blocked by , or, if not, block two nondisjoint paths of . In the first situation, we necessarily have , thus and one path of are blocked but the path of remains unblocked. In the second situation, two nondisjoint paths are blocked by ; thus, count as one blocker for (they block only one of the disjoint candidate paths). Therefore, it is sound to assume that does not count as a blocker for .

At the exception of , each of all other blockers for (i.e., ) can block at most one of the disjoint candidate paths. In total, it is possible to select disjoint paths from to T (i.e., considering the candidate paths ). Therefore, considering that at most of these disjoint paths are blocked, there always remain path to route to T. See Figure 4.

Figure 4

A vertex of can block at most one of the disjoint candidate paths for a vertex (selected paths in blue) [9].

Maximum path length would be obtained if is routed to T with a path of , hence of length . To route to T, we first enumerate the paths of (starting with ). If all are blocked, it means that is an (indirect) blocker, thus inducing the check of at most one path of (i.e., if the first checked path of is blocked, the second one will always do). Hence, the worst-case time complexity to route to T is , and, in total, is required to route all vertices () to T. ☐

In an (n, k)-torus (

Assume that, given the pair routed to , there exists vertex () that cannot be disjointly routed to T without going through , that is, each of all candidate paths to T for as per Lemma 1 are blocked. See Figure 5. If such a vertex does not exist, all vertices (, ) can be routed to T provided that if there exists a unique pair () with 3 disjoint candidate paths to T without going through blocked by the paths for it is routed first to T, (i.e., before all the other pairs (, )), and there is thus nothing to prove.

Figure 5

Illustration of the case with the pair blocking 3 paths for the pair when routed to the subtorus . Vertex is not routable to subtorus T without going through . (Dimension names are given on the right for reference.)

For to be fully blocked, vertex or () needs to be on dimension , that is, blocking path . By definition of the candidate paths (see Lemma 1), this vertex or is the only one that can block two candidate paths for , as all the other vertices () can block, at most, one candidate path for . Hence, the candidate paths for are blocked by at least vertices or (). In other words, for vertex to be fully blocked, vertex or needs to be on , the unique direct path to T for . Since at least vertices or are required to fully block , it means that one of these blockers blocks in addition to one of the two candidate paths for on another dimension, say (). All other blockers are positioned 2 per dimension (), at the exception of one blocker that is on the dimension (on the other side of compared with the blocker that blocks two paths at once for ). Hence, there exists one unique such vertex of (here ) that is not routable to T.

So, for a vertex to be fully blocked, is induced, otherwise it would mean that at least one pair vertex needs not be routed at all (i.e., a path of zero length will do for that vertex), and, thus, all other vertices can be routed to by Lemma 1.

Furthermore, since , either there exists a pair with that can be routed to without going through T (in place of the pair ) with the paths and (see Figure 6a). Or, if blocks one of these two paths, the pair can be routed to without going through T (in place of the pair ) with the paths and (see Figure 6b). Because of the uniqueness of such a vertex not routable to T, we have shown that it is possible to disjointly route one pair to and the other pairs to T.

Figure 6

Illustration of the case with the pair blocking 3 paths for the pair when routed to the subtorus . Vertex is not routable to the subtorus T. (a) Pair is routed to in place of . (b) Pair is not routable to (because of ), so pair is routed to in place of .

Considering the two subtori T and , the value of is at most . Given that the pair vertices are to be routed towards T (resp. ) not going through (resp. T), and by Lemma 1, the maximum path length is .

Regarding time complexity, pair vertices can be routed to T and as follows. Let be the pair routed to . By Lemma 1, this takes time. If either or blocks a path for u a vertex of a pair (, ), do as follows, and otherwise each of all pairs except the one routed to is routed to T with a path as per Lemma 1 that does not go through . Check if u is routable to T with a path as per Lemma 1 that does not go through ; this takes time. If u is routable to T, starting with the pair , each of all pairs except is routed to T with a path as per Lemma 1 that does not go through . If u not routable to T, discard the paths for to and instead route an arbitrary pair () to with the paths not going through T, with the possibility that blocks when routed to , in which case it is the pair that is routed to , with the paths not going through T. Each of all pairs except the one routed to is routed to T with a path as per Lemma 1 that does not go through . Hence, the induced total time complexity is that of Lemma 1: . ☐

3. Routing Algorithm

In an (n, k)-torus (, ), given c pairs () satisfying (, ); thus, allowed, this problem consists in finding a path connecting each pair (), and such that the selected c paths are mutually vertex-disjoint. The algorithm execution trace of a sample instance of the pairwise routing problem is given in Section 4.

First, one should note that a torus of dimension 1 (i.e., ) is isomorphic to a ring. Hence, in this case, , and it is trivial to connect the unique source-destination vertex pair by traversing the ring. So, we henceforth assume that . The main idea of the proposed routing algorithm is to follow a divide-and-conquer approach by considering the (n, k)-torus as a k-set of (, k)-tori, connecting one source-destination pair in one such subtorus, and solving the problem recursively for the remaining pairs in another, distinct subtorus. We proceed according to the following cases.

3.1. Base Case:

This is point-to-point routing in a torus, and thus dimension-order routing can be applied to find a shortest path .

Find a subtorus such that the following three conditions hold:

In other words, subtorus either includes no source vertex and no destination vertex, includes at most one source vertex and no destination vertex, includes at most one destination vertex and no source vertex, or includes one single source vertex, say , and one single destination vertex .

The selection of subtorus sets dimension to reduce the original (n, k)-torus to a set of k (, k)-subtori.

First, source-destination pair is selected as follows. If , any pair will do, so select one arbitrarily, say (). If , let . Otherwise, that is , let . In the remaining of this section, assume without loss of generality that , in other words that the source-destination pair to be connected inside is .

Second, considering selected pair , select subtorus T distinct from , such that .

Route one source-destination pair to and the other pairs towards T as per Lemma 2.

If for the pair that is routed to , say with the paths and , we have with , consider the vertex that is the closest to . Select the subpath of and the subpath of , and discard the subpath of and the subpath of . Otherwise, apply the algorithm recursively in to connect to .

For each pair routed to T, say with the paths and , such that with , consider the vertex that is the closest to . Select the subpath of and the subpath of , and discard the subpath of and the subpath of . Define E the set of all such source-destination pairs.

For each source-destination pair not in E, apply the algorithm recursively in T.

3.2. General Case:

An illustration of the algorithm general case is given in Figure 7.

Figure 7

Disjointly connecting one source-destination pair inside subtorus and the other pairs inside subtorus T [9].

3.3. Special Case: and

Select subtorus as in Step 1 of the general case, and deduce a pair as in Step 2 of the general case. Route pair to without going through T, and the other pair to T with at most one possible path going through (this may require exchanging the roles of T and as explained in the proof of correctness below).

For each of the two pairs (), if the selected paths and are not disjoint, that is both include a same vertex u, discard the subpath of and the subpath of . Otherwise, complete the connection of to by traversing the subtorus of . The subtori are 1-dimensional and thus isomorphic to a ring. It is thus trivial to connect , possibly avoiding one vertex.

4. Execution Trace Example

In this section, considering the following disjoint pairwise routing problem instance, a possible execution trace of the proposed routing algorithm is detailed. In a (4, 5)-torus, let , and be the set of vertex pairs to be disjointly connected. Algorithm steps such as subtorus and subpath selection are given in Table 2. The torus arity, here , never changes and does thus not appear in the table.

Table 2

A possible algorithm execution trace in a (4, 5)-torus and the four vertex pairs where and .

n	Pairs	δ	γ(T^′,δ)	γ(T,δ)	Selected paths to T^′
4	(s_1,d_1), (s_2,d_2), (s_3,d_3), (s_4,d_4)	1	1	3	s_1→(1,1,0,4)=s1′
					d_1→(1,0,4,4)=d1′
					Selected paths to T
					s_4→(3,4,4,1)=s4′
					d_4→(0,3,0,2)→(4,3,0,2)→(3,3,0,2)=d4′
					s_3→(3,4,0,2)=s3′
					d_3→(4,4,0,3)→(3,4,0,3)=d3′
					s_2→(4,2,1,2)→(3,2,1,2)=s2′
					d_2
Path completion in T^′: s1′→(1,0,0,4)→d1′.
n	Pairs	δ	γ(T^′,δ)	γ(T,δ)	Selected paths to T^′
3	(s2′,d_2), (s3′,d3′), (s4′,d4′)	2	0	1	s2′→(3,3,1,2)→(3,4,1,2)→(3,0,1,2)=s2″
					d_2→(3,2,4,2)→(3,3,4,2)→(3,4,4,2)→(3,0,4,2)=d2′
					Selected paths to T
					s3′→(3,4,0,3)→(3,3,0,3)→(3,2,0,3)→(3,1,0,3)=s3″
					d3′→(3,3,0,3)→(3,2,0,3)→(3,1,0,3)=d3″
					s4′→(3,3,4,1)→(3,2,4,1)→(3,1,4,1)=s4″
					d4′→(3,3,0,1)→(3,2,0,1)→(3,1,0,1)=d4″
Path completion in T^′: s2″→(3,0,0,2)→d2′, and en route to T: s3′→d3′.
n	Pairs	Selected path
2	(s4″,d4″)	s4″→d4″ (base case c=1: dimension-order routing)

5. Proof of Correctness

First, dimension-order routing is applied in the base case of the recursion when there is one single source-destination pair. As recalled in Section 2, this process consists in traversing the torus one dimension after the other, concretely for each dimension starting from source vertex coordinate and traversing dimension until reaching destination vertex coordinate. This common algorithm is trivially correct.

For Step 1, it is required to show the existence of a subtorus . Along an arbitrary dimension , there are k () subtori (). Amongst them, if there is a subtorus that satisfies , we can select it as . Now, let us assume that such a subtorus does not exist. Then, because (), we have . This induces , which is a contradiction. Hence, always exists.

For Step 2, the existence of pair is trivial. Regarding the existence of a subtorus , it is recalled that the selection of fixes dimension inducing subtori. Therefore, on the one hand, excluding , there remain candidate subtori for T. On the other hand, selected pair induces at most two additional unavailable subtori for T (i.e., if in the same subtorus, only 1 additional unavailable subtorus is induced, and zero additional unavailable subtorus is induced if ). Hence, there remain at least available subtori for T. Since , we have .

The feasibility of Step 3 is proved by Lemma 2. For Step 4, at most one source-destination pair is to be connected recursively inside . Since , the dimension of is at least 2, and the problem can thus be solved recursively in (this is the base case of the algorithm). In Steps 4 and 5, the two paths to the appropriate subtorus, say T, for a pair are checked for the inclusion of a common vertex outside T. The only case for such a common vertex to exist is when the two paths are in the same direction (i.e., both taken either from or ), otherwise this would mean that the common vertex is in T. Hence, the common vertex outside T that is the closest to is also the closest to .

For Step 6, because one path is connected inside (or on the way to ), the number of paths to select recursively in T is at most . Since T is of dimension , the problem can be solved recursively inside T.

Finally, regarding the second base case of the recursion, the special case , two source-destination pairs need to be connected inside a -torus. Each of these two pairs is connected in a distinct subtorus. The existence of the two subtori T and has already been shown previously for the general case.

The vertices of pair , say , are first routed to without going through T. Since , there always remains at least one path disjoint with the vertices of the other pair to route towards . For the second pair , the paths of to may fully block (i.e., not routable as per Lemma 1 to T without going through ) one or both vertices of . If one single vertex of , say u, is fully blocked, route u towards T by going through with the path to T through . This path q always remains unblocked since, for u to be fully blocked to T, one vertex of , say v, is on to T, blocking two candidate paths to T for u, and the other vertex is in , precisely the neighbor of u that is opposite to the neighbor of u that is included in the path to for v. Hence, path to T through is always disjoint with the paths to selected for . Since with the selection of , and by the selection of the path q, subtorus includes one single vertex of the path q. See Figure 8a. If both vertices of are fully blocked by the paths to for , it means that and that are blocking both and towards T. Hence, route instead to (with to ) and to T (with to T). See Figure 8b.

Figure 8

Illustration of the case with the pair originally selected to be routed to . (a) The vertex is fully blocked to T if not going through . (b) Both are fully blocked to T: is routed instead to , and to T.

The two subtori are one-dimensional, that is, isomorphic to a ring. It is thus trivial to complete the connection of each of the two pairs inside their respective subtori, even if there is one vertex to be avoided in subtorus : either the clockwise or counter-clockwise ring traversal will do.

6. Complexities

Let function represent the time complexity of the proposed algorithm in an (n, k)-torus with c source-destination pairs (). And, let the function represent the maximum length of a path selected by the algorithm inside an (n, k)-torus with c source-destination pairs ().

The base case of the recursion induces the selection of a path with a dimension-order routing algorithm, thus inducing an time complexity and a maximum path length of . Hence, and .

For Step 1, subtorus is selected. A subtorus is selectable as if the stated three conditions hold. The first condition can be checked by iterating the source and destination vertices, testing inclusion inside the current subtorus. Testing vertex inclusion in a subtorus is achieved by checking the vertex coordinate for each dimension, inducing then an time complexity. Hence, the first condition is checked for one subtorus in time. Checking the second and third conditions induces the same time complexity. Therefore, since for an arbitrary dimension at most c subtori are unavailable as , it is needed to check at most c subtori for the three conditions, thus inducing an total time complexity.

For Step 2, selecting the pair is done by iterating each source-destination pair, each time testing the inclusion of the pair source and destination vertices inside . A total time complexity of is thus induced. The time complexity of Step 3 is directly induced by Lemma 2: . For Step 4, the two paths to are checked similarly, which thus induces an time complexity. In addition, if these two paths do not collide, the pair connection is completed in an (, k)-torus, thus inducing an time complexity. For Step 5, the two paths to T for each pair are checked for inclusion of a common vertex. The paths for one pair are thus checked in time. Hence, all pair paths are checked in time. For Step 6, time complexity is .

In the special case , two subtori are selected as in Step 1 of the general case, thus inducing an time complexity. The selection of the paths for the two pairs may require checking all the candidate paths as per Lemma 1, thus inducing an time complexity. An additional is required to check whether the selected pair paths are disjoint. Finally, routing inside one-dimensional subtori is possible, checking whether the selected path includes the vertex to avoid (), thus being time. Hence, in total, this special case is time. The maximum path length is obtained when k links are taken to route both the source and destination vertices to the designated subtorus, and with links for routing inside one-dimensional subtori, thus in total .

The above discussion can be summarized in the following theorem.

In an (n, k)-torus (

A path of maximum length could be selected as follows: each recursive step induces k links to route the source vertex to the designated subtorus, k links to route the destination vertex to the designated subtorus, and this until reaching a base case, either with a path of links selected by dimension-order routing, or with two paths each of length at most . This is summarized with the following recursive expression:

Hence, the maximum path length is , which is equal to if and to otherwise, given that . However, since in the case we have, on the one hand, and, on the other hand, , the maximum path length can be expressed as for any n.

The total worst-case time complexity is given by the following recursive expression:

Hence, the total time complexity of the proposed routing algorithm is . ☐

7. Empirical Evaluation

We have implemented the algorithm proposed in this paper in order to realize its empirical evaluation, and especially to inspect its practical behavior: how the algorithm performs in average. The computer used for this experiment was equipped with an Intel Core i5-7300U CPU (clocked at 2.60 GHz), 8 GB RAM and ran Windows 10 64-bit.

By using this computer implementation, we have repetitively and automatically solved a large number of random instances of the pairwise disjoint-path routing problem in a torus. Precisely, in an (n, )-torus, we have solved for each value of n () a total of 10,000 random routing problem instances. For each of these instances, the correctness of the selected paths has been checked (e.g., path disjointness), and the maximum length of the selected paths was stored. Then, for each value of n, the average of the stored maximum path lengths for this value of n was computed. Hence, our results include for each n both the maximum and the average of the obtained 10,000 maximum path lengths. The number of vertex pairs was set to to maximize the routing difficulty. For each n, the maximum and average of the maximum path lengths are given in Figure 9; the theoretical upper bound on the maximum path length is also given for reference.

Figure 9

Empirical evaluation: maximum and average maximum (with standard deviation) path lengths of paths selected by the proposed algorithm in an (n, )-torus.

Then, we have measured the average execution time for one problem instance: see Figure 10; the worst-case time complexity is also plotted for reference.

Figure 10

Empirical evaluation: average execution time to solve one problem instance with the proposed algorithm in an (n, )-torus.

Regarding maximum path lengths, one can first note that there is some distance between the theoretical upper bound on the maximum path length and the obtained results. This is a good indicator of the efficiency of the proposed algorithm, especially given that for small values of n the upper bound is almost tight on the maximum path length. Regarding time complexity, it can be observed from the obtained results that the average performance of the algorithm is significantly better than the theoretical worst-case time complexity.

8. Conclusions

The torus topology is very popular for the interconnection network of massively parallel systems such as the modern supercomputers Fujitsu K, IBM Blue Gene/L, IBM Blue Gene/P, and Cray Titan. In this paper, an algorithm that solves the pairwise disjoint-path routing problem in a torus has been proposed. This routing problem consists in the selection of mutually vertex-disjoint paths between given vertex pairs, and it is critical to maximize system dependability and data communication efficiency. We have then formally shown that in an n-dimensional k-ary torus, for c () vertex pairs, the described algorithm selects disjoint paths of lengths at most with a worst-case time complexity of . Furthermore, the practical behavior of the proposed algorithm has been inspected by conducting computer experiments, showing that performance on average was significantly better than the established formal worst-case complexities.

As for future works, it will be meaningful to investigate whether the theoretical maximum path length is attainable, and if not, try to refine it. For example, this might be achieved by more wisely selecting the subtori used for disjoint routing. Even though the selection of subtorus may not leave many options, the selection of subtorus T that was used to solve the problem recursively could be done such that shorter paths to route pair vertices to T are selected.