web.ece.ucsb.edu · journal of interconnection networks vol. 13, nos. 1 & 2 (2012) 1250002 (48...

Journal of Interconnection Networks

Vol. 13, Nos. 1 & 2 (2012) 1250002 (48 pages)

World Scientific Publishing Company

DOI: 10.1142/ S0219265912500028

1250002-1

NEARLY OPTIMAL NODE-TO-SET PARALLEL

ROUTING IN OTIS NETWORKS

WEIDONG CHEN

Department of Computer Science

South China Normal University

Guangzhou 510631, China

WENJUN XIAO

School of Software Engineering

South China University of Technology

Guangzhou 510641, China

BEHROOZ PARHAMI*

Department of Electrical and Computer Engineering

University of California

Santa Barbara, CA 93106-9560, USA

*[email protected]

Received 22 September 2009

Revised 26 November 2012

The node-to-set parallel routing problem for a k-connected network Γ is as follows: given

a node s and k other nodes t1, t2, ... , tk in Γ, find k node-disjoint paths connecting s and

ti, for 1 ≤ i ≤ k. From the viewpoint of applications in synthesizing fast and resilient

*Corresponding author.

http://dx.doi.org/10.1142/S0219265912500028

1250002-2

W. Chen, W. Xiao & B. Parhami

collective communication operations, it is desirable to make the parallel paths as short as

possible. Building such paths is a nontrivial problem for a general network. Optical

transpose interconnection system (OTIS, also known as swapped) networks, a class of

hierarchical structures built of n identical n-node factor networks, are known to be

maximally fault-tolerant for any connected factor network, implying that they have

maximal connectivity. We propose a general algorithm for the node-to-set parallel routing

problem in OTIS/swapped networks that yields paths of length no greater than D + 4 in

O(∆2 + ∆ f

(n)) time, where D and ∆ represent the diameter and degree of the OTIS

network and O(f(n)) is the time complexity of a shortest-path routing algorithm for the

n-node factor network. Our node-to-set routing algorithm is shown to have optimal time

complexity for certain OTIS networks of practical interest, including OTIS-Mesh and

OTIS-Hypercube.

Keywords: Connectivity; fault tolerance; node-disjoint paths; parallel routing algorithm; OTIS

network; swapped network.

1. Introduction

Optical transpose interconnection system (OTIS) networks are useful structures

for parallel computation and communication.1, 2

An OTIS network with n2 nodes

is a two-level swapped architecture built of n copies of an n-node factor network

that constitute its clusters.3 A simple rule for intercluster connectivity (node j in

Nearly Optimal Node-to-Set Parallel Routing in OTIS Networks

1250002-3

cluster i connected to node i in cluster j, for all i ≠ j) leads to regularity,

modularity, fault tolerance, and algorithmic efficiency of the resulting networks.

OTIS networks have received considerable attention in recent years, and they now

occupy a special place among real-world architectures for parallel and distributed

systems.4,5

A number of algorithms have been developed for routing, selection,

sorting,6,7

numerical computation,8,9

and image processing10

on OTIS networks.

Multiple paths in a network Γ are node-disjoint if all the nodes contained in

them are distinct, except possibly for their starting and ending nodes. Finding

node-disjoint paths (or parallel routing) in networks is one of the fundamental

problems in design and implementation of parallel and distributed computing

systems.11,12

Because communication time can dominate processor execution time

in many situations, it is important for a network to be capable of efficient routing

of data among nodes. Use of node-disjoint paths for this purpose not only

guarantees freedom from conflicts, and thus high performance, but also allows for

successful routing in the event of node and/or link failures.13,14

A measure of

network fault tolerance is the existence of alternate paths between nodes: the more

node-disjoint paths, the better. A network Γ is maximally fault-tolerant if and only

if there exist at least δ(Γ) node-disjoint paths between two distinct nodes in Γ,

where δ(Γ) is the minimum node degree of Γ.15,16

1250002-4


One might seek k node-disjoint or parallel paths in four distinct situations: (1)

Node-to-node, where the parallel paths must lead from source node s to

destination node t; (2) Node-to-set, where the parallel paths must lead from source

node s to k destination nodes ti; (3) Set-to-set, where the parallel paths must

connect each one of k source nodes si to one (distinct, but arbitrarily chosen)

destination node tji from among k given nodes ti; (4) k-pairs, where the parallel

paths must connect node pairs si and ti, 1 ≤ i ≤ k. The set-to-set and the k-pairs

parallel routing problems are NP-hard for a general network.17−19

For the

node-to-node parallel routing problem, Menger’s theorem15

guarantees the

existence of at least k parallel paths between any two nodes in a k-connected

network. The same guarantee of existence is provided by Menger’s theorem for

the node-to-set problem in a k-connected network. In both cases, however, the

existence of the paths does not imply that they are easy to find, especially if one

aims to minimize the longest or average path length.

A general approach for node-to-node and node-to-set parallel routing problems

is the flow technique, that takes O(N 2.5) time, where N is the number of nodes.

20

The nearly cubic time complexity can render this approach impractical for general

networks of very large orders. Node-to-node and node-to-set disjoint paths have

been efficiently constructed for a variety of popular networks by making use of


1250002-5

specific structural properties.12,13,21−25

Node-to-set disjoint paths were first studied

by Rabin,26

who noted their usefulness in devising efficient and fault-tolerant

randomized routing algorithms.

Previous research on node-disjoint paths in OTIS networks has been limited to

constructing node-to-node disjoint paths when the OTIS network is built of a

maximally fault-tolerant factor network. The methods used take advantage of the

corresponding constructions of node-disjoint or parallel paths in the associated

factor networks.27−29

Recently, a general construction of a maximal number of

node-to-node disjoint paths has led to the proof that any OTIS network built of a

connected factor network is maximally fault-tolerant.30

This discovery, which

implies that OTIS networks have maximal connectivity15

regardless of the factor

network on which they are based, has rendered obsolete a number of earlier

network-specific results.

The node-to-set parallel routing problem for OTIS networks has not been

solved previously. The node-to-set problem is more difficult than the

node-to-node case, because the latter can be readily reduced to the former. While

it is not difficult to obtain efficient construction strategies for node-to-set disjoint

paths in particular instances of OTIS networks, such as OTIS-Hypercube, by

taking advantage of the specific structure of their factor networks, it would be

1250002-6


much more productive to study general methods that are applicable to OTIS

networks built of any factor network. Such a general construction of node-to-set

disjoint paths in OTIS networks, based only on the interconnection rule of this

class networks and with no reference to specific properties of a particular factor

network, is what is being proposed here.

Let D, ∆, and N be the diameter, maximal node degree, and order (total number

of nodes) of an OTIS network, built of an arbitrary connected factor network. The

algorithm proposed in this paper yields the required number of node-disjoint paths

of length no greater than D + 4 within this arbitrary OTIS network in

O(∆2+∆f( N )) time, if the factor network of order n has a shortest-path routing

algorithm of time complexity O(f(n)). This parallel-path construction algorithm is

optimal in terms of time complexity for a number of OTIS networks of practical

interest, such as OTIS-Mesh and OTIS-Hypercube.

The rest of this paper is organized as follows. In Sec. 2, OTIS networks are

defined and related notions that are needed in our constructions and proofs are

introduced. The algorithm for the node-to-set parallel routing problem in OTIS

networks is presented in Sec. 3, with its performance analyzed in Sec. 4. Section 5

contains two example applications of the node-to-set parallel routing algorithm.

Section 6 concludes the paper.


1250002-7

2 Preliminaries

Because networks are often modeled as graphs, we use the terms “graph” and

“network” interchangeably. Let Γ be a simple undirected graph (graph, for short)

with vertex (node) set V(Γ) and edge (link) set E(Γ). The number of nodes of

Γ, |V(Γ)|, is called its order. For v ∈ V(Γ), we denote by degΓ(v) the degree of v in

Γ, by NΓ(v) = u ∈ V | (v, u) ∈ E(Γ) the open neighborhood of v, and by NΓ[v] =

NΓ(v) ∪ v its closed neighborhood. The maximum degree among the vertices of

Γ is denoted by ∆(Γ) and the minimum degree by δ(Γ). The distance between

nodes u and v, denoted by dΓ(u, v), is the length of a shortest path between u and

v. The diameter D(Γ) of Γ is the maximal distance between any two nodes of Γ.

Two paths from u to v are node-disjoint (also called parallel paths) if they share

no internal node. The connectivity of Γ is the minimal number of nodes whose

removal can cause Γ to become disconnected or trivial (degenerating to a single

node). A graph is said to be k-connected if its connectivity is at least k. A graph Γ

of connectivity δ(Γ) is maximally fault-tolerant. Other notation and terminology

used in this paper follow those in Ref. 15.

Definition A. OTIS (Swapped) network1,3

: The OTIS (swapped) network OTIS-Ω,

derived from the graph Ω, is a graph with the vertex set V(OTIS-Ω) =⟨g, p⟩ | g, p

∈ V(Ω) and the edge set E(OTIS-Ω), which is the union of two sets: intracluster

1250002-8


edges (⟨g, p1⟩, ⟨g, p2⟩) | g ∈ V(Ω), (p1, p2) ∈ E(Ω) and intercluster edges (⟨g, p⟩,

⟨p, g⟩) | g, p ∈ V(Ω), g ≠ p.

Fig. 1. OTIS-C4, where C4 is a cycle of order 4 and V(C4) = 0, 1, 2, 3.

In OTIS-Ω, the graph Ω is called the basis network or factor network. If Ω has

n nodes, then OTIS-Ω is composed of n node-disjoint subnetworks called clusters,

each of which is isomorphic to the factor network Ω. A node of OTIS-Ω that is

labeled ⟨g, p⟩ constitutes node p of cluster g. An intercluster (or optical) link

connects node p of cluster g to node g of cluster p, for all p ≠ g. No intercluster

link is incident to node p of cluster p. An example OTIS network appears in Fig. 1.

Intuitively, if every cluster in OTIS-C4 is viewed as a supernode, then the resulting

graph of all the supernodes along with all the optical links will form the complete

graph K4.

Based on Definition A, the following basic topological parameters of OTIS-Ω

are easily derived as functions of the corresponding parameters of Ω27,29:

0 1

2 3

0 1

2 3

0 1

2 3

0 1

2 3

Cluster 0 Cluster 1

Cluster 2 Cluster 3

Node ⟨1,1⟩

Node ⟨2,3⟩

Node ⟨3,0⟩

Node ⟨0,1⟩

Fig. 1


1250002-9

• N = n2, where N = |V(OTIS-Ω)|, n = |V(Ω)|

• degOTIS-Ω(⟨g, g⟩) = degΩ(g), and for g ≠ p: degOTIS-Ω(⟨g, p⟩) = degΩ(p) + 1

• dOTIS-Ω(⟨g, p1⟩, ⟨g, p2⟩) = dΩ(p1, p2), and for g1 ≠ g2:

dOTIS-Ω(⟨g1, p1⟩, ⟨g2, p2⟩) = mindΩ(p1, g2) + dΩ(g1, p2) + 1, dΩ(p1, p2) + dΩ(g1,

g2) + 2

• ∆(OTIS-Ω) = ∆(Ω) + 1, and δ(OTIS-Ω) = δ(Ω)

• D(OTIS-Ω) = 2D(Ω) + 1

By Definition A, one also easily knows that OTIS-Ω is connected if and only if

Ω is connected. Furthermore, we have the following result.

Theorem A. Maximal fault tolerance30

: OTIS-Ω is maximally fault-tolerant if the

factor network Ω is a connected graph.

In what follows, we assume that the factor graph Ω is connected and that a

shortest-path routing algorithm in Ω is known. This shortest-path routing

algorithm in Ω can be used to perform shortest-path routing in OTIS-Ω. For

convenience, in any cluster g, the edge from u to v is denoted by ⟨g, u → v⟩, and a

shortest path from x to y that is completely contained in cluster g, by ⟨g, x ⇒ y⟩.

For any g ≠ p, ⟨g, p⟩ → ⟨p, g⟩ denotes the intercluster link from ⟨g, p⟩ to ⟨p, g⟩.

Additionally, for consistency and brevity, null links and null paths such as u → u

and x ⇒ x are allowed as segments (subpaths or components) of routing paths. In

1250002-10


this way, when x ⇒ y is a segment of a routing path, say, we do not have to treat

the case x = y separately, given that the null path segment would not contribute

any distance or latency. This leads to far fewer cases in our analyses and proofs.

On the null path x ⇒ x, node x is both the immediate predecessor of, and the

immediate successor to, itself.

From Theorem A, the connectivity of OTIS-Ω is δ(Ω), given that δ(OTIS-Ω) =

δ(Ω). The node-to-set parallel routing problem in OTIS-Ω is to construct k

node-disjoint paths from a given source node to k given destination nodes, where

k ≤ δ(Ω).

3 The Parallel Routing Algorithm

In this section, we present an algorithm for a more general node-to-set parallel

routing problem in OTIS-Ω: Given a source node ⟨g0, s = t0⟩ and a set T = ⟨g1, t1⟩,

⟨g2, t2⟩, . . . ,⟨gk, tk⟩ of k destination nodes in OTIS-Ω, where k ≤ mindegΩ(ti) | 0

≤ i ≤ k and ⟨g0, s⟩ ∉ T, construct k node-disjoint paths from the source node ⟨g0,

s⟩ to every destination node ⟨g, t⟩ ∈ T; furthermore, strive to make the constructed

paths as short as possible, in the sense of the longest of these paths not being

much longer than the network diameter. Note that δ(Ω) ≤ mindegΩ (ti) | 0 ≤ i ≤ k.

Notationally, cluster g0 is the source cluster, cluster gi (for 1 ≤ i ≤ k) is a


1250002-11

destination cluster, and any other cluster that is traversed by these paths

constitutes an intermediate cluster.

3.1 Basic Idea

We first provide an intuitive description of our algorithm. Because the connected

factor network Ω is not necessarily maximally fault-tolerant, there is no guarantee

that there exist two node-disjoint paths between a pair of distinct nodes in Ω, even

if δ(Ω) ≥ 2 (see Fig. 2). On the other hand, from the rule for intercluster

connectivity in OTIS-Ω, we know that for an arbitrary node v in a cluster g, every

node of NΩ[v] (other than node g, when g ∈ NΩ[v]) is connected outwards to a

different cluster by an intercluster link. Thus, there are at least |NΩ[v]| − 1

node-disjoint ways for a path beginning at v to leave cluster g immediately. Based

on these facts, we will aim to force the paths beginning at the source node and

each destination node to leave their current clusters as quickly as possible to

ensure the node-disjoint property (Note that |NΩ[ti]| = degΩ(ti) + 1 ≥ k + 1, for 0 ≤

i ≤ k). We will also aim to have each intermediate cluster visited by exactly one

path, as a way of ensuring nonintersecting paths. Moreover, in order to keep these

paths short, we will allow no more than two intermediate clusters on a path, and

construct every subpath contained in a cluster by using the given shortest routing

Fig. 2

1250002-12


algorithm of Ω. Note that using two intermediate clusters is necessary in some

circumstances to ensure node-disjoint paths. It is readily seen, for example, that

given the factor network of Fig. 2, a path parallel to (node-disjoint from) the

single-step path ⟨g, u → v⟩, from node u to node v of the same cluster g, must

leave cluster g for an intermediate cluster g′, and then reenter cluster g from

another intermediate cluster g″.

Fig. 2. An example 1-connected factor graph Ω with δ(Ω) = 2.

According to the strategy described above, for a typical destination node ⟨g, t⟩

∈ T, the path from ⟨g0, s⟩ to ⟨g, t⟩ will begin at node s in cluster g0, leave cluster g0

immediately by way of a cluster-g0 neighbor of s, and then pass through at most

two intermediate clusters (called the first intermediate cluster and the second

intermediate cluster, if any, respectively), until it eventually enters the destination

cluster g along an intercluster link, typically incident to a neighbor of t in cluster g,

prior to arriving at t. Figure 3 provides an overall view of our strategy for

constructing node-to-set disjoint paths.

u v


1250002-13

Fig. 3. Illustrating the construction of node-to-set disjoint paths in an OTIS network.

Construction of subpaths and selection of intermediate clusters so as to satisfy

the following three criteria yields the required k node-disjoint paths:

(C1) Subpaths contained in the source cluster are node-disjoint.

(C2) Possible multiple subpaths contained in any destination cluster are

node-disjoint.

(C3) The intermediate clusters of one path, if any, are different from those of

any other path, and also from the source cluster and any of the destination

clusters.

Cluster g2 (g3) Cluster g4 (g5,g6)

Cluster g0 (g1)

First intermediate clusters

Second intermediate clusters

s

t1

t2 t3 t5 t6

t4

Cluster s*

Cluster t*

t*

s*

Cluster x

NΩ[s]

x

x

g0

t*

s*

g4

g0

g2

1250002-14


3.2 Routing Functions

The construction of subpaths contained in the source cluster and the destination

clusters is related to the selection of intermediate clusters. In fact, we have the

following results.

• A path from ⟨g0, s⟩ to ⟨g0, t⟩ has no intermediate cluster if and only if the path is

⟨g0, s ⇒ t⟩.

• A path from ⟨g0, s⟩ to ⟨g, t⟩, g ≠ g0, has no intermediate cluster if and only if the

path is of the form ⟨g0, s ⇒ g⟩ → ⟨g, g0 ⇒ t⟩.

• A path from ⟨g0, s⟩ to ⟨g, t⟩, g ≠ g0, has only one intermediate cluster s* ∈ NΩ[s]

if and only if the path is of the form ⟨g0, s → s*⟩ → ⟨s*

, g0 ⇒ g⟩ → ⟨g, s* ⇒ t⟩.

• A path from ⟨g0, s⟩ to ⟨g, t⟩ has a first (second) intermediate cluster s* ∈ NΩ[s]

(t* ∈ NΩ[t])

if and only if the path is of the form ⟨g0, s → s

*⟩ → ⟨s*, g0 ⇒ t

*⟩ →

⟨t*, s

* ⇒ g⟩ → ⟨g, t* → t⟩.

For convenience, we take ⟨g0, s⟩ to be the implied source node in all cases, and

use F1(⟨g, t⟩) and F2(⟨g, t⟩) to denote the first and the second intermediate cluster

indices, respectively, selected for the path from ⟨g0, s⟩ to ⟨g, t⟩. Clearly, F1 can be

viewed as a function from T to NΩ[s] ∪ Λ, and F2 as a function from T to V(Ω)

∪ Λ, such that F2(⟨g, t⟩) ∈ NΩ[t] ∪ Λ for any ⟨g, t⟩ ∈ T, where Λ represents


1250002-15

null. In particular, by F1(⟨g, t⟩) = F2(⟨g, t⟩) = Λ, we mean the path from ⟨g0, s⟩ to

⟨g, t⟩ has no intermediate cluster, and by F2(⟨g, t⟩) = Λ and F1(⟨g, t⟩) ≠ Λ, we mean

the path has only one intermediate cluster. Given F1(⟨g, t⟩) and F2(⟨g, t⟩), it is

trivial to obtain the path from ⟨g0, s⟩ to ⟨g, t⟩. Thus, our focus should be on

computing the two functions F1 and F2, from which we can obtain the desired k

node-disjoint paths.

Definition 1. Let F1 be a function from T to NΩ[s] ∪ Λ, and F2 a function from

T to V(Ω) ∪ Λ, such that F2(⟨g, t⟩) ∈ NΩ[t] ∪ Λ for every ⟨g, t⟩ ∈ T. We call

F1 and F2 a pair of routing functions if the k paths obtained from F1 and F2 are

node-disjoint.

To compute a pair of routing functions satisfying Definition 1, we must

construct appropriate subpaths contained in the source cluster and in the

destination cluster for every destination node. In computing F2(⟨g, t⟩) or F1(⟨g, t⟩)

for a new destination node ⟨g, t⟩ ∈ T, we must ensure that all subpaths constructed

thus far in the source cluster and in every destination cluster satisfy Criteria (C1)

and (C2), and that all the intermediate clusters utilized thus far satisfy Criterion

(C3). If so, we say that F2(⟨g, t⟩) and F1(⟨g, t⟩) are valid. Obviously, if F2(⟨g, t⟩)

and F1(⟨g, t⟩) are valid for every node ⟨g, t⟩ ∈ T, then F1 and F2 are the desired

pair of routing functions.

1250002-16


To minimize the number of intermediate clusters used in routing paths, we try

to pick, for each destination cluster g, a destination node in cluster g so that the

path to it does not need a second intermediate cluster. Accordingly, we will first

compute F2(⟨g, t⟩) for all ⟨g, t⟩ ∈ T, and then derive F1(⟨g, t⟩). We describe the

computation of F2 and F1, beginning with a few needed additional notations. Note

that if cluster g0 is also a destination cluster, then the path construction process is

very similar to the case where the destination cluster g is different from g0, but it

contains more than one destination node. Thus, we proceed with the assumption g

≠ g0.

Definition 2. For any x ∈ NΩ[s], x is fixed node if it belongs to an already

constructed subpath contained in the source cluster; otherwise x is a free node.

Definition 3. Let cluster g contain more than one destination node. A destination

node ⟨g,t⟩ is a head destination node of cluster g ift satisfies the following

conditions:

(1)

where argmin, when applied to a function, yields the argument that minimizes the

function. The subpath of the head destination node ⟨g,t⟩ contained in cluster g is

argmindΩ(g0, t′) | ⟨g, t′⟩ ∈ T , if g ∈ NΩ[s] and g is free

argmin dΩ(s, t′) | ⟨g, t′⟩ ∈ T , otherwise

t


1250002-17

g0 ⇒t if g ∈ NΩ[s] and g is free; it is s ⇒t, otherwise.

Definition 4. Let cluster g contain more than one destination node, ⟨g,t⟩ be a

head destination node of cluster g, and p be the immediate predecessor oft on the

subpath leading to ⟨g,t⟩ within cluster g. For any ⟨g, t⟩ ∈ T such that t ≠t, let G

= g0, g1, … , gk ∪ t′ | cluster t′ has been selected as a second intermediate

cluster, Dt = t′ | ⟨g, t′⟩ ∈ T − t. We call G the global forbidden set of ⟨g, t⟩,

and G ∪ Dt ∪ p the forbidden set of ⟨g, t⟩.

(A) Computing F2

We compute F2 for all destination nodes in one cluster, then proceed to another

cluster, and so on; if cluster g0 is also a destination cluster, we begin with cluster

g0. For a cluster g containing only one destination node ⟨g, t⟩, the path from ⟨g0, s⟩

to ⟨g, t⟩ will not need a second intermediate cluster, and F2(⟨g, t⟩) = Λ. For every

cluster g containing more than one destination node, we first pick out a head

destination node ⟨g,t⟩ in cluster g that will not need a second immediate cluster.

We then compute F2(⟨g,t⟩) first, and proceed with computing F2 for every other

destination node ⟨g, t⟩ in cluster g.

Computing F2 for the head destination node ⟨g,t⟩ in cluster g: If g ∈ NΩ[s] and

g is free, the path from ⟨g0, s⟩ to ⟨g,t⟩ will be ⟨g0, s → g⟩ → ⟨g, g0 ⇒t⟩. This path

1250002-18


requires no intermediate cluster, leading to F1(⟨g,t⟩) = F2(⟨g,t⟩) = Λ. Otherwise,

that is, if g ∉ NΩ[s] or g is a fixed node in NΩ[s], the path from ⟨g0, s⟩ to ⟨g,t⟩

does not need a second intermediate cluster, and F2(⟨g,t⟩) = Λ.

Computing F2 for every other destination node ⟨g, t⟩ in cluster g: The path from

⟨g0, s⟩ to ⟨g, t⟩ leaves cluster g immediately, at node t itself or at a neighbor node

of t in cluster g, implying that F2(⟨g, t⟩) ∈ NΩ[t] ∪ Λ. Specifically, if NΩ[t] − (G

∪ Dt ∪ p) ≠ ∅, we compute F2(⟨g, t⟩) as:

(2)

By the definition of G, once F2(⟨g, t⟩) has been computed, we will have t ∈ G and

F2(⟨g, t⟩) ∈ G; hence, all the nodes on the subpath of ⟨g, t⟩ contained in cluster g

will belong to G. Hence, the subpath of ⟨g, t⟩ in cluster g is node-disjoint from all

the other subpaths constructed thus far in cluster g; it is node-disjoint from the

subpath of ⟨g,t⟩ in cluster g, because neither nodet nor node p is on it. Thus, the

obtained F2(⟨g, t⟩) is valid. On the other hand, if NΩ[t] − (G ∪ Dt ∪ p) = ∅, we

use the three rules (R1), (R2), and (R3), to be introduced later, to compute F2(⟨g,

t⟩); the validity of such a choice will also be proven later.

t, if t ∉ G;

an arbitrary node ∈ NΩ[t] − (G ∪ Dt ∪ p), otherwise

F2(⟨g, t⟩) =


1250002-19

Procedure Routing-Function Compute F2(⟨g, t⟩) and F1(⟨g, t⟩) for all ⟨g, t⟩ ∈ T

1. Initialize:

Let PathSet = ∅, G = g0, g1, … , gk, and mark every x ∈ NΩ[s] as free.

2. Compute F2 for all ⟨g, t⟩ ∈ T:

2.1. If cluster g0 is a destination cluster Then

Lett = argmindΩ(s, t′) | ⟨g0, t′⟩ ∈ T, x and p be the immediate successor to s and

the immediate predecessor oft, respectively, on the path s ⇒t.

Case 1 dΩ(s,t) ≥ 2: Add ⟨g0, s ⇒t⟩ to PathSet, mark x as fixed, and set

F1(⟨g0,t⟩) = F2 (⟨g0,t⟩) = Λ.

Case 2 dΩ(s,t) ≤ 1: For every ⟨g0, t⟩ ∈ T such that t ∈ NΩ[s], add ⟨g0, s → t⟩ to

PathSet, mark t as fixed, and set F1(⟨g0, t⟩) = F2(⟨g0, t⟩) = Λ.

To compute F2(⟨g0, t⟩) for every other node ⟨g0, t⟩ in cluster g0, if any, use Eq. (2)

and add F2(⟨g0, t⟩) to G if NΩ[t] − (G ∪ Dt ∪ p) ≠ ∅; otherwise, use Rule (R1).

2.2. For every destination cluster g such that g ≠ g0 Do

If (cluster g contains more than one destination node) Then

Case 1 g is a free node in NΩ[s]: Lett = argmindΩ(g0, t′) | ⟨g, t′⟩ ∈ T , and p be

the immediate predecessor oft on the path g0 ⇒t. Add ⟨g0, s → g⟩ → ⟨g, g0

⇒t⟩ to PathSet, mark g as fixed, and set F1(⟨g,t⟩) = F2(⟨g,t⟩) = Λ.

Case 2 g ∉ NΩ[s] or g is a fixed node in NΩ[s]: Lett = argmindΩ(s, t′) | ⟨g, t′⟩ ∈

T , and p be the immediate predecessor oft on the path s ⇒t. Set F2 (⟨g,t⟩) =

Λ.

To compute F2(⟨g, t⟩) for every other node ⟨g, t⟩ in cluster g, use Eq. (2) and add

F2(⟨g, t⟩) to G if NΩ[t] − (G ∪ Dt ∪ p) ≠ ∅; otherwise use Rule (R1), (R2), or (R3).

Else Set F2 (⟨g, t⟩) = Λ cluster g contains only one destination node

3. Compute F1 for all ⟨g, t⟩ ∈ T:

3.1. For every free node x in NΩ[s] Do

Case 1 x = gi for some i in the range 1 ≤ i ≤ k: Add ⟨g0, s → x = gi⟩ → ⟨gi, g0 ⇒ ti⟩

to PathSet, mark x as fixed , and set F1(⟨gi, ti⟩) = F2(⟨gi, ti⟩) = Λ.

Case 2 x = F2(⟨g0, t⟩) for some ⟨g0, t⟩ ∈ T : Add ⟨g0, s → x → t⟩ to PathSet, mark x

as fixed, and set F1(⟨g0, t⟩) = F2(⟨g0, t⟩) = Λ.

Case 3 x = F2(⟨g, t⟩) for some ⟨g, t⟩ ∈ T and g ≠ g0: Mark x as fixed, set F1(⟨g, t⟩) =

x and F2(⟨g, t⟩) = Λ.

3.2. For every destination node ⟨g, t⟩ such that F1(⟨g, t⟩) has not yet been computed Do

Pick an arbitrary free node s* in NΩ[s], set F1(⟨g, t⟩) = s*, and mark s* as fixed.

Fig. 4. The procedure Routing-Function, which returns the intermediate clusters F1(⟨g, t⟩) and F2(⟨g, t⟩),

if any, used in constructing the parallel path from node ⟨g0, s⟩ to node ⟨g, t⟩ for all ⟨g, t⟩ ∈ T.

1250002-20


(B) Computing F1

Once the function F2 has been computed, it is an easy matter to compute F1, a

function from T to NΩ[s] ∪ Λ. Note that there may exist free nodes in NΩ[s] that

belong to G. Thus, to satisfy Criterion (C3), we first need to fix these free nodes

in NΩ[s] by constructing paths needing no intermediate cluster or merging two

identical intermediate clusters into one. Then, we can randomly assign a free node

x in NΩ[s] to F1(⟨g, t⟩) for every destination node ⟨g, t⟩ whose F1 value has not yet

been computed because x ∉ G. It is easy to see that if F2(⟨g, t⟩) is valid for every

node ⟨g, t⟩ ∈ T, then F1(⟨g, t⟩) will be valid for every node ⟨g, t⟩ ∈ T.

The procedure Routing-Function for computing F1 and F2 is shown in Fig. 4. In

these computations, if a path needs no intermediate cluster, then it will be

constructed completely and directly recorded in PathSet. Next, we assume NΩ[t] −

(G ∪ Dt ∪ p) = ∅ when computing F2(⟨g, t⟩) for some ⟨g, t⟩ such that t ≠t,

where cluster g contains more than one destination node, and p is the immediate

predecessor tot on the subpath of the head destination node ⟨g,t⟩ within cluster g;

a situation we refer to as “an obstacle.” Let g* be the immediate successor to s on

the path s ⇒ g. Thus, we have g* ∈ NΩ[s]. In this case, we apply Rules (R1)–(R3)

below to compute a valid F2(⟨g, t⟩), where α = (p ≠t ∧ p ∈ NΩ[t] ∧t ∉ G).

Fig. 4

here


1250002-21

Fig. 5. Examples of applying Rules (R1), (R2), and (R3) to compute a valid F2(⟨g, t⟩), when NΩ[t] − (G ∪

Dt ∪ p) = ∅. Nodes shown as ⊗ belong to the forbidden set of ⟨g, t⟩, exceptingt and p.

Fig. 5

here

(a) Using Rule (R1)

Cluster g s

p

t t

Clustert

Cluster g s

p

t t

Clustert

Cluster g s

p

t t

g0

Cluster g0

s

g g*

NΩ[s]

(b) Using Rule (R2)

Cluster g

Cluster g0

s

p

t t

g0

s

g g*

NΩ[s]

(c) Using Rule (R3)

Cluster g

s

p

t t

g0

F2(⟨g*,t

*⟩)

Cluster g0

s

g g*

NΩ[s]

Cluster g*

Cluster F2(⟨g*,t

*⟩)

g0

t*

F2(⟨g*,t

*⟩)

g g*

Cluster g0

s

g g*

NΩ[s]

Cluster g

s

p

t t

g0

F2(⟨g*,t

*⟩)

Cluster F2(⟨g*,t

*⟩)

Cluster g*

g0

t*

g g*

1250002-22


(R1) α is true: We exchange the roles oft and t in cluster g, that is, we make

⟨g, t⟩ the head destination node in cluster g. Thus, for ⟨g, t⟩, the subpath

contained in cluster g will be s ⇒ p → t (g0 ⇒ p → t, if g is a free node in

NΩ[s]) and F2(⟨g, t⟩) = Λ. For ⟨g,t⟩, the subpath contained in cluster g will

be the single nodet and F2(⟨g,t ⟩) =t (see Fig. 5(a)).

(R2) α is false and g* is a free node in NΩ[s]: Assume that g ∉ NΩ[s] and g0 ∈

NΩ[t].

Case 1 g0 ∉ Dt: For ⟨g, t⟩, we construct the path ⟨g0, s ⇒ g⟩ → ⟨g, g0 →

t⟩, which needs no intermediate cluster, and set F2(⟨g, t⟩) = F1(⟨g, t⟩) =

Λ (see Fig. 5(b)).

Case 2 g0 = t′ ∈ Dt, such that t′ ≠t and F2(⟨g, t′⟩) ∈ NΩ[t]: For ⟨g, t⟩, we

set F2(⟨g, t⟩) = F2(⟨g, t′⟩). Then, for ⟨g, t′⟩, we construct the new path

⟨g0, s ⇒ g⟩ → ⟨g, g0 = t′⟩, needing no intermediate cluster, and set

F2(⟨g, t′⟩) = F1(⟨g, t′⟩) = Λ.

Case 3 g0 =t, p ∈ NΩ[t] and p ≠t: Node ⟨g, t⟩ is made the head

destination node of cluster g, in lieu of ⟨g,t⟩. That is, for ⟨g, t⟩, we use

the cluster-g subpath s ⇒ p → t, and set F2(⟨g, t⟩) = Λ. Then, for ⟨g,t⟩,

we construct the path ⟨g0, s ⇒ g⟩ → ⟨g, g0 =t⟩, needing no

intermediate cluster, and set F2(⟨g,t⟩) = F1(⟨g,t⟩) = Λ.


1250002-23

(R3) α is false and g* is a fixed node in NΩ[s]: Assume that g ∉ NΩ[s], and let

⟨g*, t

*⟩ be one destination node in cluster g* such that F2(⟨g

*, t

*⟩) ∈ NΩ[t].

Case 1 F2(⟨g*, t

*⟩) ∉ Dt: For ⟨g, t⟩, we set F2(⟨g, t⟩) = F2(⟨g*, t

*⟩), and

then recompute F2(⟨g*, t

*⟩) in cluster g* (see Fig. 5(c)).

Case 2 F2(⟨g*, t

*⟩) = t′ ∈ Dt such that t′ ≠t and F2(⟨g, t′⟩) ∈ NΩ[t]: For

⟨g, t⟩ and ⟨g, t′⟩, we set F2(⟨g, t⟩) = F2(⟨g, t′⟩) and F2(⟨g, t′⟩) = t′,

respectively, and then recompute F2(⟨g*, t

*⟩) in cluster g*.

Case 3 F2(⟨g*, t

*⟩) =t, p ∈ NΩ[t] and p ≠t: Node ⟨g, t⟩ is made the head

destination node in cluster g, in lieu of ⟨g,t⟩. For ⟨g, t⟩, we use the

cluster-g subpath s ⇒ p → t, and set F2(⟨g, t⟩)=Λ. Then, we set

F2(⟨g,t⟩)=t and recompute F2(⟨g*,t

*⟩) in cluster g*.

Note that once an obstacle occurs, there will be exactly one rule among Rules

(R1)–(R3) whose conditions are met; the corresponding assumptions of the rule,

if any, will be proved to be true in Sec. 4. It is readily observed that in Rules

(R1)–(R3), we obtain F2(⟨g, t⟩) via changing the head destination node or a

second intermediate cluster, or by constructing a path that needs no intermediate

cluster. The validity of such a choice for F2(⟨g, t⟩) will also be proven in Sec. 4. It

is worth pointing out that in using these rules, if node ⟨g, t⟩ becomes the head

destination node in cluster g, in lieu of ⟨g,t⟩, then the subpath s ⇒ p → t is not

1250002-24


necessarily the same as the subpath s ⇒ t obtained by using shortest-path routing

in Ω directly, although they both are shortest paths from s to t in Ω. Therefore, in

order to subsequently construct the complete path based on F2 and F1, we should

reserve the subpath. For consistency and brevity, we still denote the subpath s ⇒

p → t simply by s ⇒ t. Similarly, the subpath g0 ⇒ p → t is denoted by g0 ⇒ t.

Moreover, when we use these rules to compute F2(⟨g, t⟩), we must update PathSet

whenever a path has been completed.

3.3 Algorithm Description

Now we can describe formally the PR-OTIS algorithm for constructing k

node-disjoint paths from the source node ⟨g0, s = t0⟩ to the destination node set T =

⟨g1, t1⟩, ⟨g2, t2⟩, . . . ,⟨gk, tk⟩ in OTIS-Ω (see Fig. 6). The algorithm consists of

two main steps. First, we compute functions F2 and F1 by calling the procedure

Routing-Function, where we construct all subpaths in the source cluster and the

destination clusters, and thus obtain all intermediate clusters (if a path has no

intermediate cluster, then it is constructed completely). Then, based on F2 and F1,

we construct desired paths for all ⟨g, t⟩ ∈ T such that F1(⟨g, t⟩) ≠ Λ or F2(⟨g, t⟩) ≠

Λ. Recall that, for ⟨g, t⟩ ∈ T, F1(⟨g, t⟩) ≠ Λ denotes the first intermediate cluster,

implying that the subpath contained in cluster g0 is s → F1(⟨g, t⟩). Similarly, F2(⟨g,

Fig. 6

here


1250002-25

t⟩) ≠ Λ denotes the second intermediate cluster, meaning that the subpath

contained in cluster g is F2(⟨g, t⟩) → t. In addition, F1(⟨g, t⟩) ≠ Λ and F2(⟨g, t⟩) = Λ

(in this case we have g≠g0) is indicative of the path not having a second

intermediate cluster. In this case, according to the methods for computing F1 and

F2, if cluster g contains only one destination node, the subpath contained in

cluster g is F1(⟨g, t⟩) ⇒ t; otherwise node ⟨g, t⟩ is the head destination node of

cluster g, and the subpath must be constructed carefully to ensure that all the

subpaths in cluster g are node-disjoint.

Now assume that cluster g (g ≠ g0) contains more than one destination node,

and let the head destination node of cluster g be ⟨g,t⟩. Because the subpath

contained in cluster g is s ⇒t (refer to Case 2 of Step 2.2 in Procedure

Routing-Function), s*

= F1(⟨g,t⟩) ∈ NΩ[s], and F2(⟨g,t⟩) = Λ, we construct the

subpath contained in cluster g as follows: s* ⇒t (a subpath of the path s ⇒t,

without the link s → s*) if s

* is on the path s ⇒t (in other words, the path s ⇒t

is the path s → s* ⇒t); otherwise, s

* → s ⇒t. The subpath is node-disjoint from

the other subpaths in cluster g, given that the method of computing F1 ensures s*

∉ G, and all the nodes on the other subpaths in cluster g belong to G (due to the

method for computing F2).

1250002-26


Algorithm PR-OTIS Node-to-set parallel routing in OTIS-Ω

Input: A source node ⟨g0, s = t0⟩ and a set T = ⟨gi, ti⟩ | 1 ≤ i ≤ k of k destination

nodes, where k ≤ mindegΩ(ti) | 0 ≤ i ≤ k.

Output: A path set PathSet containing k parallel paths from ⟨g0, s⟩ to ⟨gi, ti⟩,1 ≤ i

≤ k.

1. Call procedure Routing-Function to compute the functions F2 and F1, and

construct those paths that pass through no intermediate cluster.

2. Construct paths that pass through at least one intermediate cluster based on

F2 and F1. For every node ⟨g, t⟩ ∈ T such that F1(⟨g, t⟩) ≠ Λ or F2(⟨g, t⟩) ≠ Λ,

add the following path from ⟨g0, s⟩ to ⟨g, t⟩ to PathSet.

Case 1 F2(⟨g, t⟩) = Λ, F1(⟨g, t⟩) = s*, and cluster g holds only one

destination node:

⟨g0, s → s*⟩ → ⟨s*, g0 ⇒ g⟩→⟨g, s

* ⇒ t⟩

Case 2 F2(⟨g, t⟩) = Λ, F1(⟨g, t⟩) = s*, and s

* is on the path s ⇒ t:

⟨g0, s → s*⟩ → ⟨s*, g0 ⇒ g⟩ → ⟨g, s

* ⇒ t⟩

Case 3 F2(⟨g, t⟩) = Λ, F1(⟨g, t⟩) = s*, and s

* is not on the path s ⇒ t:

⟨g0, s → s*⟩ → ⟨s*, g0 ⇒ g⟩ → ⟨g, s

* → s ⇒ t⟩

Case 4 F1(⟨g, t⟩) = s* and F2(⟨g, t⟩) = t

*:

⟨g0, s → s*⟩ → ⟨s*, g0 ⇒ t

*⟩ → ⟨t*, s

* ⇒ g⟩ → ⟨g, t* → t⟩

Fig. 6. The algorithm PR-OTIS for constructing k parallel paths from source node ⟨g0, s⟩

to k destination nodes ⟨gi, ti⟩, 1 ≤ i ≤ k, in OTIS-Ω.

According to the discussion above, if Rules (R1), (R2), and (R3) can be used to

remove every obstacle that possibly occurs, so as to obtain a valid value of F2 for

the corresponding destination node in Procedure Routing-Function, then F2 and

F1 are a pair of routing functions we need since F2(⟨g, t⟩) and F1(⟨g, t⟩) are valid

for every node ⟨g, t⟩ ∈ T. This claim will be proven in Sec. 4.


1250002-27

4 Algorithm Analysis

In this section, we prove the correctness of Algorithm PR-OTIS and analyze its

performance with regard to running time and the length of the resulting parallel

paths. For this purpose, we first need to prove that Rules (R1), (R2), and (R3) can

be used to remove obstacles that possibly occur in Procedure Routing-Function.

Assume that we are computing F2(⟨g, t⟩) in the procedure Routing-Function for

some ⟨g, t⟩ ∈ T, t ≠t, in a cluster g containing more than one destination node.

Recall that ⟨g,t⟩ is the head destination node of cluster g, p is the immediate

predecessor oft on the subpath of ⟨g,t⟩ contained in cluster g, G is the global

forbidden set of ⟨g, t⟩, and Dt = t′ | ⟨g, t′⟩ ∈ D − t. Furthermore, we let Dt* =

t′ | t′ ∈ Dt and F2(⟨g, t′⟩) has not yet been computed. Then, we have G ∪ Dt ∪

p = G ∪ Dt* ∪ t ∪ p according to the method for computing F2.

Therefore, if NΩ[t] − (G ∪ Dt* ∪ t ∪ p) = ∅, we are encountering an

obstacle and need to prove that Rules (R1), (R2), and (R3) can be used to remove

the obstacle. That is, we now need to prove the following crucial lemma.

Lemma 1. If NΩ[t] − (G ∪ Dt* ∪ t ∪ p) = ∅, then we can use Rule (R1),

(R2), or (R3) to compute a valid F2(⟨g, t⟩).

The proof outline is as follows. First we show that when an obstacle occurs,

there exists exactly one rule among Rules (R1)–(R3), and one operation of the

1250002-28


rule, whose conditions and assumptions are met, concluding that the operation is

feasible. Second, we prove that during the operation, the generated subpaths and

the computed F2 values thus far satisfy Criteria (C1), (C2) and (C3). These

assertions are supported by the following two main facts that are obvious by

construction or will be proved to be true in the full proof of Lemma 1.

• During the use of any one of the Rules (R1)-(R3), no new intermediate cluster

is selected, and all the subpaths contained in cluster g are clearly node-disjoint by

construction, implying Criteria (C2) and (C3) are satisfied.

• A subpath of length more than one in cluster g0 is potentially constructed only

if cluster g0 is a destination cluster or Rule (R2) is used. On the other hand, if

cluster g0 also is a destination cluster, then Rule (R1) can be used to remove any

possible obstacle, while if cluster g0 is not a destination cluster, then Rule (R2)

will be used at most once. Therefore, cluster g0 contains at most one subpath of

length more than one, which implies that Criterion (C1) is satisfied.

Please refer to the appendix for details of the proof of Lemma 1.

Based on Lemma 1, we establish the correctness of Algorithm PR-OTIS in the

following theorem.

Theorem 2. Given a source node ⟨g0, s = t0⟩ and a set T = ⟨g1, t1⟩, ⟨g2, t2⟩, . . . ,

⟨gk, tk⟩ of k destination nodes in OTIS-Ω such that ⟨g0, s⟩ ∉ T, Algorithm


1250002-29

PR-OTIS provides k node-disjoint paths from the source node to every destination

node in T, provided k ≤ mindegΩ(ti) | 0 ≤ i ≤ k.

Proof. We first need to show that all the operations in Procedure

Routing-Function are feasible. For this purpose, we only need to prove that the

operations in Steps 2.1 and 2.2 are feasible when an obstacle does occur in

computing F2; the other operations are obvious. The assertion is true by Lemma 1.

Therefore, the algorithm generates k paths from the source node to every

destination node in T. Moreover, by Lemma 1, F2 and F1 are a pair of routing

functions, as needed, since F2(⟨g, t⟩) and F1(⟨g, t⟩) are valid for every node ⟨g, t⟩ ∈

T, as discussed previously. Hence, the node-disjoint property of these k paths is

ensured, completing the proof.

Next, we analyze the performance of Algorithm PR-OTIS with regard to

running time and the lengths of constructed paths. In the following, we denote by

n the order of Ω, by f(n) the time complexity of the given shortest-path routing in

Ω, by N the order of OTIS-Ω, by D the diameter of OTIS-Ω, and by ∆ the

maximal node degree of OTIS-Ω.

Theorem 3. The time complexity of Algorithm PR-OTIS is O(∆2+∆f( N )) and

each path constructed by it is of length no greater than D + 4.

Proof. We first consider the time complexity of this algorithm. Recall that |NΩ[t]|

1250002-30


≤ ∆ for all t ∈ V(Ω), and k < ∆. In Procedure Routing-Function, for every

destination node ⟨g, t⟩ ∈ D, computing F2(⟨g, t⟩) or F1(⟨g, t⟩) needs O(∆) time;

thus, the total time for computing the routing functions F2 and F1 is O(k∆), since

there are k destination nodes. Moreover, constructing the paths passing through no

intermediate cluster in Procedure Routing-Function, and constructing the other

paths based on F2 and F1 take O(kf(n)) time, since k paths need to be constructed,

and each one requires O(f(n)) time to construct. Hence, the time complexity of

Algorithm PR-OTIS is bounded by O(∆2 + ∆f( N )) due to k < ∆ and N = n

2.

Next, we consider the length of the paths constructed. Note that the length of

the path u ⇒ v is at most D(Ω) for any pair of nodes u and v in Ω. Since every

path is explicitly constructed in this algorithm, it is easy to verify immediately

that the length of a path passing through no intermediate cluster is at most 2D(Ω)

+ 1, and the length of a path passing through one or two intermediate clusters is at

most 2D(Ω) + 5. Therefore, the length of paths constructed is at most 2D(Ω) + 5 =

D + 4, given that D = 2D(Ω) + 1.

We note that if ∆ = O(f(n)) and the given shortest-path routing algorithm in Ω is

time-optimal, then the running time of Algorithm PR-OTIS will be bounded by

O(∆f(n)), which is optimal in the sense that any node-to-set routing algorithm

takes at least Θ(∆f(n)) time in the worst case to construct k = ∆ − 1 node-disjoint


1250002-31

paths in the OTIS network. For a number of OTIS networks of practical interest,

such as OTIS-Mesh and OTIS-Hypercube, the factor networks do have an optimal

shortest-path routing algorithm and ∆ = O(f(n)) does hold. Thus, Algorithm

PR-OTIS is optimal for such OTIS networks.

On the other hand, a path from ⟨g0, s⟩ to ⟨g, t⟩ constructed by Algorithm

PR-OTIS is clearly optimal if its length is the distance between the source node

and the destination node. From the distance formula between two nodes in

OTIS-Ω in Sec. 2, we know that there exists a shortest path passing through at

most one intermediate cluster between two nodes in OTIS-Ω. We can verify

directly the following results about near optimality in path length for some of the

k node-disjoint paths constructed by Algorithm PR-OTIS.

•••• For ⟨g, t⟩ ∈ T such that g = g0, if the path constructed from ⟨g0, s⟩ to ⟨g0, t⟩ has

no intermediate cluster, then the length of the path is dOTIS-Ω(⟨g0, s⟩, ⟨g0, t⟩) =

dΩ(s, t).

•••• For ⟨g, t⟩ ∈ T such that g0 ≠ g, if there exists one shortest path from ⟨g0, s⟩ to

⟨g, t⟩ that passes through no intermediate cluster, and the constructed path

from ⟨g0, s⟩ to ⟨g, t⟩ has no intermediate cluster, then the length of the path is

dOTIS-Ω(⟨g0, s⟩, ⟨g, t⟩).


1250002-32


⟨g, t⟩ that passes through one intermediate cluster, and the constructed path

from ⟨g0, s⟩ to ⟨g, t⟩ has only one intermediate cluster, then the length of the

path is at most dOTIS-Ω(⟨g0, s⟩, ⟨g, t⟩) + 2.


⟨g, t⟩ that passes through no intermediate cluster, and the constructed path

from ⟨g0, s⟩ to ⟨g, t⟩ has two intermediate clusters, then the length of the path

is at most dOTIS-Ω(⟨g0, s⟩, ⟨g, t⟩) + 6.

The Rabin number of a k-connected graph Γ is the minimum l such that for any

k + 1 distinct nodes s, t1, t2, … , tk of Γ, there exist k node-disjoint paths of length

at most l from s to t1, t2, … , tk, respectively [26]. It has been shown that finding

the Rabin number of a general graph is NP-hard. From Theorem 3, we

immediately have the following corollary.

Corollary 4. The Rabin number of OTIS-Ω is bounded from above by D + 4.

5 Example Applications

In this section, we provide two example applications of Algorithm PR-OTIS. As

the first application, we show that this algorithm can be used to solve efficiently

the node-to-node parallel routing problem in OTIS networks.

Corollary 5. Given a shortest-path routing algorithm of time complexity O(f(n))


1250002-33

in an n-node connected factor network Ω, Algorithm PR-OTIS can generate k

node-disjoint paths of length at most D + 5 between two distinct nodes ⟨gs, s⟩ and

⟨gt, t⟩ in OTIS-Ω in O(∆2+∆f( N )) time, where D, ∆, and N are the diameter,

maximal node degree, and order of OTIS-Ω, respectively, and k = mindegΩ(s),

degΩ(t).

Proof. Without loss of generality, we assume |degΩ(s)| ≥ | deg Ω(t)| = k, which

implies that |NΩ[s]| ≥ |NΩ[t]| = k + 1. We consider the following instance of the

node-to-set parallel routing problem in OTIS-Ω: The source node is ⟨gs, s⟩ and the

destination node set is ⟨gt, t1⟩, ⟨gt, t2⟩, … , ⟨gt, tk⟩, where t1, t2, …, tk is a

k-element subset of NΩ[t] that includes t. By Theorems 2 and 3, Algorithm

PR-OTIS can construct k node-disjoint paths from ⟨gs, s⟩ to ⟨gt, ti⟩, 1 ≤ i ≤ k, in

O(∆2 + ∆f( N )) time, and the length of each constructed path is at most D + 4. It

is readily seen that these k node-disjoint paths can be extended by one step, if

required, to obtain k node-disjoint paths of length at most D + 5 from ⟨gs, s⟩ to ⟨gt,

t⟩.

As a second application, we investigate the performance of Algorithm PR-OTIS

when applied to OTIS networks built of binary hypercubes as factor networks.

Hypercube networks and their variants, including OTIS-Hypercube, have been

extensively studied.28,31

We use Qk to denote a k-dimensional hypercube network

1250002-34


(k-cube, for short) and let n = 2k denote its order. Thus, we have k = δ(Qk) = ∆(Qk)

= log2 n. It is well-known that Qk has a shortest routing algorithm of time

complexity O(log n). Theorems 2 and 3 immediately yield the following result.

Corollary 6. Given a source node ⟨g0, s⟩ and k destination nodes ⟨g1, t1⟩, ⟨g2,

t2⟩, …, ⟨gk, tk⟩ in OTIS-Qk, Algorithm PR-OTIS generates k node-disjoint paths of

length at most D + 4 from the source node to every destination node in O(log2 N)

time (an optimal time), where N = 22k

and D = 2k + 1 are the order and the

diameter of OTIS-Qk.

Note that the optimality of Algorithm PR-OTIS stated in Corollary 6 results

from the fact that the worst case running time of any algorithm for constructing k

paths in OTIS-Qk is Θ(k log n), which translates to Θ(log2

N), given that k = log2 n

and N = n2.

Figure 7 illustrates the constructions by Algorithm PR-OTIS on two instances

of the node-to-set parallel routing problem for OTIS-Q3.


1250002-35

(a) An instance of k = 3 such that g1 is a free node in NΩ[s], where F1(⟨g1, t1⟩) = F2(⟨g1, t1⟩) = ˄.

(b) An instance of k = 3 such that no destination cluster number is a free node number in NΩ[s].

Fig. 7. The parallel path constructions of Algorithm PR-OTIS (heavy lines) on two instances of OTIS-Q3.

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

Cluster 000 Cluster 001


Cluster 100

Cluster 110

Cluster 101

Cluster 111

⟨g2=g1, t2⟩

⟨g0,s⟩

⟨g1,t=t1⟩

⟨g3, t3⟩

⟨g1,g0⟩

⟨g0,g1⟩

⟨g1, p⟩

⟨g1,g1⟩

F2(⟨g2, t2⟩)=111

F1(⟨g2, t2⟩)=001

F1(⟨g3, t3⟩)=100

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011

100

110

101

111

000

010

001

011



Cluster 100

Cluster 110

Cluster 101

Cluster 111

⟨g2=g1, t2⟩

⟨g3, t3⟩

⟨g1,t=t1⟩

⟨g1, p⟩

⟨g0,s⟩

F1(⟨g1, t1⟩)=001

F2(⟨g2, t2⟩)=111

F1(⟨g2, t2⟩)=010

F1(⟨g3, t3⟩)=100

1250002-36


To evaluate the practical performance with regard to the length of paths

constructed by Algorithm PR-OTIS for OTIS-Qk, we conducted a simulation

experiment, where for each k between 2 and 20, we selected 10,000 random

combinations of the source node and the destination node set, applying the

algorithm in each case to determine the mean maximum path length. Figure 8

depicts the mean maximum path length derived from these experiments, where

the horizontal axis represents the dimension k of the factor network Qk, and the

vertical axis represents the average among 10,000 maximum lengths for each k.

From Fig. 8, we can conclude that for OTIS-Qk, in practice, the maximum

length of k node-disjoint paths from one source node to k destination nodes

constructed by Algorithm PR-OTIS is generally far below the upper bound D + 4,

and slightly above the maximal path length that results directly from the distance

formula, the latter clearly providing a lower bound for the maximum length. Note

that, for any specific instance of the node-to-set routing problem, the maximum

length of the required paths constructed by any algorithm would generally be

somewhat greater than the maximal distance from the source node to the set of

destination nodes, in order to ensure the node-disjoint property.

Fig. 8

here


1250002-37

051015202530354045

2 4 6 8 10 12 14 16 18 20Dimension k of the factor hypercube Q k

Path

len

gth

Fig. 8. Average maximum length of paths constructed by Algorithm PR-OTIS for OTIS-Qk.

6 Conclusion

In this paper, we have proposed a general and efficient algorithm for the

node-to-set parallel routing problem in an OTIS network built of an arbitrary

connected factor network. If D, ∆, and N represent the diameter, node degree, and

order of the OTIS network, the proposed algorithm constructs the requisite

number of node-disjoint paths that are of length at most D + 4 in O(∆2 + ∆f( N ))

time, provided the factor network of order n has a shortest-path routing algorithm

of time complexity O(f(n)). We have shown that the algorithm is optimal in terms

of time complexity for a number of OTIS networks of practical interest.

Our general algorithm supersedes prior node-to-set parallel routing schemes for

specific factor networks, and it can also be used for node-to-node parallel routing

in OTIS networks. As an example application, the algorithm provides

Path length bound: D + 4

Mean max path length

Mean max distance

1250002-38


node-disjoint paths (that are only slightly longer than the distance-based optimal

paths) in optimal time for OTIS-Hypercube.

Important open problems include finding general and efficient algorithms for

the set-to-set and the k-pair parallel routing problems in OTIS networks.

Acknowledgment

This research of W. D. Chen and W. J. Xiao was supported by the National Natural Science

Foundation of China (Grant Nos. 60973150 and 61170313) and the Natural Science

Foundation of Guangdong Province, China (Grant No. 10451063101006313).

Appendix: Proof of Lemma 1

Please refer to Section 4 of the paper for the proof outline.

In order to prove Lemma 1, we first prove the following sequence of assertions.

Assertion 1.

Furthermore, if the maximum of k + 1 or k + 2 is attained, then the four sets G, Dt*,

t and p will be pairwise disjoint, and exactly one destination node in every

destination cluster will not need a second intermediate cluster.

Proof. According to the method for computing F2, if a destination cluster g′

contains c destination nodes (c ≥ 1), we need to make use of a second

intermediate cluster for no more than c – 1 of the destinations. Thus, the total

k + 1, if the source cluster g0 is a destination cluster

k + 2, otherwise

|G ∪ Dt* ∪ t ∪ p| ≤


1250002-39

contribution of cluster g′ to |G| will be at most c, given that G initially contains g′.

In particular, if cluster g0 is also a destination cluster, then the contribution of

cluster g0 to |G| will be no greater than the number of destinations in cluster g0;

otherwise, its contribution will be 1, owing to g0 ∈ G. Therefore, after computing

F2(⟨g, t⟩) for all ⟨g, t⟩ ∈ T, |G| will be at most k if cluster g0 is a destination cluster

and at most k + 1, otherwise. Now, assume that we are computing F2(⟨g, t⟩) for ⟨g,

t⟩ ∈ T, and that there are a destination nodes including ⟨g, t⟩ in cluster g whose F2

values have not yet been computed; i.e., |Dt*| = a − 1 (a ≥ 1) due to t ∉ Dt

*. At the

moment, |G| is at most k − a if cluster g0 is a destination cluster and at most k + 1

− a, otherwise. Hence, |G ∪ Dt* ∪ t ∪ p|, which is at most |G| + |Dt

*| +

|t | + |p|, will be no greater than k + 1 if cluster g0 is a destination cluster and

no greater than k + 2, otherwise. Clearly, if the maximum of k + 1 or k + 2 is

attained, then the sets G, Dt*, t , and p must be pairwise disjoint, and exactly

one destination node in every destination cluster will not need a second

intermediate cluster.

Assertion 2. Let the source cluster g0 also be a destination cluster. If NΩ[t] − (G ∪

Dt* ∪ t ∪ p) = ∅, then p ≠t, p ∈ NΩ[t], andt ∉ G.

Proof. From Assertion 1, we have |G ∪ Dt* ∪ t ∪ p | ≤ k + 1, and that if the

maximum of k + 1 is attained, then the sets G, Dt*, t and p are pairwise

1250002-40


disjoint. Since |NΩ[t]| ≥ k + 1, NΩ[t] − (G ∪ Dt* ∪ t ∪ p) = ∅ implies NΩ[t]

= G ∪ Dt* ∪ t ∪ p, and the sets G, Dt

*, t , andp are pairwise disjoint.

Hence, we have p ≠t , p ∈ NΩ[t], andt ∉ G.

Assertion 3. Let the subpath of ⟨g,t⟩ contained in cluster g be of form g0 ⇒t. If

NΩ[t] − (G ∪ Dt* ∪ t ∪ p) = ∅, then p ≠t, p ∈ NΩ[t], andt ∉ G.

Proof. Recall that |NΩ[t]| ≥ k + 1 and |G ∪ Dt* ∪ t ∪ p | ≤ k + 2 by Assertion

1. We consider the two cases of g0 ∈ NΩ[t] and g0 ∉ NΩ[t]. First, if g0 ∉ NΩ[t], then

NΩ[t] − (G ∪ Dt* ∪ t ∪ p) = ∅ implies |G ∪ Dt

* ∪ t ∪ p| = k + 2, and

NΩ[t] ∪ g0 = G ∪ Dt* ∪ t ∪ p due to g0 ∈ G. By Assertion 1, the sets G,

Dt*, t , and p are pairwise disjoint. Thus, we have p ≠t, p ∈ NΩ[t], andt ∉ G.

Secondly, if g0 ∈ NΩ[t], then dΩ(g0,t) ≤ dΩ(g0, t) ≤ 1 due to dΩ(g0,t) = mindΩ(g0,

t′) | ⟨g, t′⟩ ∈ T . This leads to p = g0, since p is the immediate predecessor oft on

the path g0 ⇒t. The proof of Assertion 1, and p =g0 ∈ G, NΩ[t] − (G ∪ Dt* ∪ t

∪ p) = ∅ suggest that NΩ[t] = G ∪ Dt* ∪ t , and the sets G, Dt

*, and t are

pairwise disjoint. Thus, we have p = g0 ≠t, p = g0 ∈ NΩ[t], andt ∉G, which

concludes this proof.

Assertion 4. If p ≠t, p ∈ NΩ[t], andt ∉ G, then Rule (R1) can be used to

compute a valid F2(⟨g, t⟩).

Proof. Without loss of generality, we assume that the subpath of ⟨g,t⟩ contained


1250002-41

in cluster g is s ⇒t; the proof for the case of the subpath being g0 ⇒t is similar.

Recall that the role of node p in the forbidden set is to ensure that the subpath s

⇒t is node-disjoint from the other subpaths contained in cluster g, since dΩ(s,t)

= mindΩ(s, t′) | ⟨g, t′⟩ ∈ T. Considering that p ≠t and p ∈ NΩ[t], we have dΩ(s, t)

= dΩ(s,t). Thus, to compute F2 for other destination nodes in cluster g, we can

replacet with t. In other words, we make ⟨g, t⟩ the head destination node in

cluster g, in lieu of ⟨g,t⟩. Then, for ⟨g, t⟩, the subpath contained in cluster g is s ⇒

p → t and F2(⟨g, t⟩) = Λ, For ⟨g,t⟩, the subpath contained in cluster g is the single

nodet, and F2(⟨g,t ⟩) =t due tot ∉ G. Hence, we can use Rule (R1) to compute

a valid F2(⟨g, t⟩).

Based on Assertions 1-4, we now can prove Lemma 1.

Lemma 1. If NΩ[t] − (G ∪ Dt* ∪ t ∪ p) = ∅, then we can use Rule (R1),

(R2), or (R3) to compute a valid F2(⟨g, t⟩).

Proof. Let α = (p ≠t ∧ p ∈ NΩ[t] ∧t ∉ G). If α is true, we can use Rule (R1) to

compute a valid F2(⟨g, t⟩) by Assertion 4. Next, we assume that α is false, that is,

p =t, p ∉ NΩ[t], ort ∈ G. Note that |NΩ[t]| ≥ k + 1 and that NΩ[t] − (G ∪ Dt* ∪

t ∪ p) = ∅ is given. Thus, if p =t or p ∉ NΩ[t], then NΩ[t] = G ∪ Dt* ∪

t , and the sets G, Dt*, and t will be pairwise disjoint by the proof of

Assertion 1. Similarly, ift ∈ G, then NΩ[t] = G ∪ Dt* ∪ p, and the sets G, Dt

*,

1250002-42


and p will be pairwise disjoint. Hence, in either case,t ∈ NΩ[t], G ∪ Dt* ⊆

NΩ[t], and the sets G and Dt* are disjoint. Note that because α is false, cluster g0 is

not a destination cluster by Assertion 2 and the subpath of ⟨g,t⟩ contained in

cluster g is s ⇒t by Assertion 3; thus, g ∉ NΩ[s] by the method for computing F2.

Let g* be the immediate successor to s on the path s ⇒ g. Clearly, g

* ∈ NΩ[s], and

we have the following two cases.

Case 1. g* is a free node in NΩ[s]: Recall that Dt = t′ | ⟨g, t′⟩ ∈ T − t, Dt

* =

t′ | t′ ∈ Dt and F2(⟨g, t′⟩) has not yet been computed, and g0 ∈ NΩ[t] due to g0 ∈

G ⊆ NΩ[t]. We have the following two subcases.

Case 1.1. g0 ∉ Dt: Clearly, Case 1 of Rule (R2) can be used to compute F2(⟨g,

t⟩).

Case 1.2. g0 = t′ ∈ Dt: In this case, F2(⟨g, t′⟩) has been computed, since we

know that G and Dt* are disjoint, and g0 ∈ G. Note that at the moment,t is the

only destination node in cluster g not needing a second intermediate cluster, that

is, F2(⟨g,t⟩) = Λ. Therefore, if F2(⟨g, t′⟩) ≠ Λ, then t′ ≠t, and F2(⟨g, t′⟩) ∈ G ⊆

NΩ[t]; thus Case 2 of Rule (R2) can be used to compute F2(⟨g, t⟩). Otherwise, that

is, for F2(⟨g, t′⟩) = Λ, we have t′ =t = g0 ∈ G, leading to NΩ[t] = G ∪ Dt* ∪ p,

and the sets G, Dt*, and p are pairwise disjoint, as discussed above. Hence, we

have g0 =t, p ∈ NΩ[t], and p ≠t, which suggests that Case 3 of Rule (R2) can be


1250002-43

used to compute F2(⟨g, t⟩).

Case 2. g* is a fixed node in NΩ[s]: According to the method for computing F2,

we know that cluster g* contains more than one destination node, and F2 has been

computed for every destination node in cluster g*(see Case 1 of Step 2.2 in

Procedure Routing-Function). In this case, there exists a destination node ⟨g*, t

*⟩

such that F2(⟨g*, t

*⟩) ≠ Λ. Hence, we have F2(⟨g*, t

*⟩) ∈ G, and thus F2(⟨g*, t

*⟩) ∈

NΩ[t], since G ∪ Dt* ⊆ NΩ[t]. We have the following two subcases.

Case 2.1. F2(⟨g*, t

*⟩) ∉ Dt: Clearly, Case 1 of Rule (R3) can be used to compute

F2(⟨g, t⟩).

Case 2.2. F2(⟨g*, t

*⟩) = t′ ∈ Dt: In this case, F2(⟨g, t′⟩) has been computed, since

we know that G and Dt* are disjoint, and t′ = F2(⟨g

*, t

*⟩) ∈ G. Note that at the

moment,t is the only destination node in cluster g not needing a second

intermediate cluster, that is, F2(⟨g,t⟩) = Λ. Therefore, if F2(⟨g, t′⟩) ≠ Λ, then t′ ≠t

and F2(⟨g, t′⟩) ∈ G ⊆ NΩ[t]; thus Case 2 of Rule (R3) can be used to compute

F2(⟨g, t⟩). Otherwise, that is, for F2(⟨g, t′⟩) = Λ, we have t′ =t = F2(⟨g*, t

*⟩) ∈ G,

and thus NΩ[t] = G ∪ Dt* ∪ p, and the sets G, Dt

*, and p are pairwise disjoint,

as discussed above. Hence, we have F2(⟨g*, t

*⟩) =t, p ∈ NΩ[t], and p ≠t, which

suggests that Case 3 of Rule (R3) can be used to compute F2(⟨g, t⟩).

1250002-44


Note that the subpath of the head destination node in cluster g* is of form g0

⇒t*, wheret

* = argmindΩ(g0, t′) | ⟨g*

, t′⟩ ∈ T, implying that it is feasible to

recompute a valid F2(⟨g*, t

*⟩) via Rule (R1) by Assertions 3 and 4.

We next prove the validity of F2(⟨g, t⟩) obtained via Rule (R2) or (R3). Since no

new intermediate cluster is selected, and all the subpaths contained in cluster g are

clearly node-disjoint by construction, Criteria (C2) and (C3) are satisfied. In order

to prove that Criterion (C1) is also satisfied, considering that g* is a free node in

NΩ[s], we only need to prove that before we use Rule (R2) to compute F2(⟨g, t⟩),

all constructed subpaths in cluster g0 are of length at most one, which suggests all

the nodes on these subpaths are within NΩ[s] of cluster g0. Note that, according to

the method for computing F2, a subpath of length more than one in cluster g0 is

potentially constructed only if cluster g0 is a destination cluster or Rule (R2) is

used. Now that we have proven that cluster g0 is not a destination cluster, we only

need to prove that Rule (R2) can be used at most once. Note that once Rule (R2)

has been used in some cluster, at least two destination nodes in that cluster will

not need a second intermediate cluster, which implies, by the proof of Assertion 1,

that |G ∪ Dt* ∪ t ∪ p| ≤ k + 1 will hold and that if the maximum of k + 1 is

attained, then the sets G, Dt*, t , and p will be pairwise disjoint. In this case,

similar to Assertion 2, we can easily prove that α is true if NΩ[t] − (G ∪ Dt* ∪ t


1250002-45

∪ p) = ∅; thus Rule (R1) can remove any obstacle that might possibly occur

later, which implies that Rule (R2) can be used at most once, as claimed.

References

[1] G. Marsden, P. Marchand, P. Harvey, and S. Esener, “Optical transpose interconnection system

architecture,” Optical Letters, 18 (1993), 1083-1085.

[2] F. Zane, P. Marchand, R. Paturi, and S. Esener, “Scalable network architectures using the optical

transpose interconnection system (OTIS),” J. Parallel and Distributed Computing, 60 (5) (2000),

521–538.

[3] C.-H. Yeh, and B. Parhami, “Swapped networks: unifying the architectures and algorithms of a wide

class of hierarchical parallel processors,” Proc. Int’l Conf. Parallel and Distributed Systems (1996), pp.

230–237.

[4] J. Rayn, “WDM: North American development trend,” IEEE Communications, 32 (2) (1998), 40-44.

[5] S. Chatterjee, and S. D. Pawlowski, “All-optical networks,” Communications of the ACM, 42 (6)

(1999), 74-83.

[6] S. Rajasekaran, and S. Sahni, “Randomized routing, selection, and sorting on the OTIS-mesh,” IEEE

Trans. Parallel and Distributed Systems, 9 (9) (1998), 833-840.

[7] C.-F. Wang, and S. Sahni, “Basic operations on the OTIS-mesh optoelectronic computer,” IEEE Trans.

Parallel and Distributed Systems, 9 (12) (1998), 1226-1236.

[8] C.-F. Wang, and S. Sahni, “Matrix multiplication on the OTIS-mesh optoelectronic computer,” IEEE

Trans. Computers, 50 (7) (2001), 635–646.

1250002-46


[9] P. K. Jana, “Polynomial interpolation and polynomial root finding on OTIS-mesh,” Parallel

Computing, 32 (2006), 301–312.

[10] C.-F. Wang, and S. Sahni, “Image processing on the OTIS-mesh optoelectronic computer,” IEEE

Trans. Parallel and Distributed Systems, 11 (2) (2000), 97–109.

[11] D. F. Hsu ,and Y. D. Lyuu, “A graph-theoretical study of transmission delay and fault tolerance,” Int’l

J. Mini and Microcomputers, 16 (1) (1994), 35–42.

[12] C.-N. Lai, One-to-Many Disjoint Paths in the Hypercube and Folded Hypercube, (PhD Dissertation,

National Taiwan University, June 2001).

[13] C.-C. Chen, and J. Chen, “Nearly optimal one-to-many parallel routing in star networks,” IEEE Trans.

Parallel and Distributed Systems, 8 (12) (1997), 1196–1202.

[14] J. Kim, S. Moh, I. Chung, and C. Yu, “Robust multipath routing to exploit maximally disjoint paths for

wireless ad hoc networks,” Proc. Int’l Workshop Sensor Networks, LNCS Vol. 3842 (Springer, 2006),

pp.306-309.

[15] D. B. West, Introduction to Graph Theory, (Prentice-Hall, 2001).

[16] T. Takabatake, and T. Nakamigawa, “Node-disjoint paths in a level block of generalized hierarchical

completely connected networks,” Theoretical Computer Science, 465 (2012), 28-34.

[17] R. M. Karp. “On the computational complexity of combinatorial problems,” Networks, 5 (1975),

45-68.

[18] J. Kleinberg, Approximation Algorithms for Disjoint Paths Problems, (PhD Dissertation, MIT, May

1996).

[19] Q. Gu, and S. Peng, “An efficient algorithm for the k-pairwise disjoint paths problem in hypercubes,”

J. Parallel and Distributed Computing, 60 (2000), 764 -774.


1250002-47

[20] S. Even, and R. E. Tarjan, “Network flow and testing graph connectivity,” SIAM J. Computing, 4 (4)

(1975), 507-518.

[21] Q. Gu, and S. Peng, “Node-to-set disjoint paths problem in star graphs,” Information Processing

Letters, 62 (4) (1997), 201-207.

[22] K. Kaneko, “An algorithm for node-to-set disjoint paths problem in bi-rotator graphs,” IEICE Trans.

Information and Systems, E89-D (2) (2006), 647-653.

[23] R.-Y. Wu, et al., “Node-disjoint paths in hierarchical hypercube networks,” Information Sciences, 177

(2007), 4200-4207.

[24] S. Zhou, W. Xiao, and B. Parhami, “Construction of vertex-disjoint paths in alternating group

networks,” The Journal of Supercomputing, 54 (2) (2010), 206–228.

[25] L. Lipták, E. Cheng, J.-S. Kim, S. W. Kim, “One-to-many node-disjoint paths of hyper-star networks,”

Discrete Applied Mathematics, 160 (13–14) (2012), 2006-2014.

[26] M. O. Rabin, “Efficient dispersal of information for security, load balancing, and fault tolerance,” J.

ACM, 36 (2) (1989), 335-348.

[27] K. Day, and A. Al-Ayyoub, “Topological properties of OTIS-networks,” IEEE Trans. Parallel and

Distributed Systems, 14 (4) (2002), 359-366.

[28] K. Day, “Optical transpose k-ary n-cube networks,” J. Systems Architecture, 50 (2004), 697-705.

[29] B. Parhami, “Swapped interconnection networks: topological, performance, and robustness attributes,”

J. Parallel and Distributed Computing, 65 (2005), 1443-1452.

[30] W. Chen, W. Xiao, and B. Parhami, “Swapped (OTIS) networks built of connected basis networks are

maximally fault tolerant,” IEEE Trans. Parallel and Distributed Systems, 20 (3) (2009), 361-366.

1250002-48


[31] Y. Saad, and M. H. Schultz, “Topological properties of hypercubes,” IEEE Trans. Computers, 37

(1988), 867–872.

web.ece.ucsb.edu · journal of interconnection networks vol. 13, nos. 1 & 2 (2012) 1250002 (48...

Documents