Efficient Reconfiguration Technique for Redundant

Proceedings of the 28th Annual Hawaii International Conference on System Sciences - 1995

Efficient Reconfiguration Technique for Redundant Ring Networks* Amiya Nayak, Nicola Santoro and Quanhu Xue School of Computer Science, Carleton University, Ottawa, Canada, KlS 5B6

Abstract

a component; the set of faulty nodes delimiting a component is called blocking. In [8], conditions are given to construct a linear array of all the non-faulty nodes; these conditions have been subsequently extended and generalized in [5]. The problem of constructing subrings has also been addressed [5, 81 but only for chordal rings where each node has link structure G = {1,2,3 , . . . . gk}. In this paper, we consider the general case of chordal rings with an arbitrary link structure G = {l,gi,g2,...,gk}, and study the problem of subring construction in the presence of set of blocking fault patterns. Since a ring network is one of the most popular topologies for local computer networks, subring construction techniques have potential applications in such networks. In this paper, we present efficient reconfiguration techniques and analyze the size of the resulting subrings. We show that the size of the subring depends not only on the size of the component, but also on the “shape” of the delimiting sets of faults. In our investigation, we concentrate on the special link configuration { 1, gk}. Since this configuration is contained in any other link configuration, it provides lower bound for the general case.

Consider a redundant ring network where each node is also connected to the nodes at distance d. In the presence of faulty nodes, the goal of a reconfiguration scheme is to construct the largest subring among the non-faulty nodes using both regular and bypass links. If the faults partition the network into components, such a subring will be entirely within a component. The set of faulty nodes delimiting a component is called a “cut”. In the literature, reconfiguration of 2-redundant rings has been studied only for the special case where d = 2. In this paper, we consider the general case of an arbitrary d >_ 2. We present efficient reconfiguration algorithms and analyze the size of the resulting subring.

1

Introduction

A common and practical approach for achieving fault tolerance in ring networks is by adding additional links (called bypasses or chords) and providing mechanisms for reconfiguration in case of Several ring networks had been node failures. suggested based on this principle [l, 2, 3, 71. The overall topological structure of these redundant rings is always highly regular. In particular, the set of ring edges (regular) and additional edges form a Circulant Graph or Chordal Ring with link structure G = (1, gr,gz, . . . . gk}. In the presence of node or link failures, it might still be possible to find one or more subrings in the original network composed solely of live nodes; that is, it could be possible to reconfigure the network so to form a ring, though of smaller size. If the faults cut the network into disconnected components, such a subring will be entirely within ‘research

supported

in part by NSERC,

grant

2

Preliminaries

Redundant ring networks with bidirectional links are considered in this paper. The basic components of such a network are the processing elements (PEs or nodes) and the links. The links can be either regular or bypass. These redundant ring networks are regular and highly symmetrical. They are called chordal rings in the literature. We assign logical identifiers to the nodes, usually consecutive integers increasing in one of

#A2415

489 1060-3425195 $4.00 0 1995 IEEE

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

Proceedings of the 28th Annual Hawaii International Conference on System Sciences - 1995

the orientations (either clockwise or counterclockwise) starting from a given node. A generalized chordal ring is formally defined as follows: Definition 1 Given a set P PN-1) of N nodes and a } of positive integers, gZ,**-r&‘k a genemlized chordal ring on P ration G is an undirected graph the set & of edges is & = {(Pi, (i=j+gmodN)V(i=j-gmodN)}

= (Po,Pl,. . ., set G = (91, where gi < gi+l, with link configuC = (P, &) where Pj) : 3 g E G, Figure 1: A blocking fault pattern for a chordal ring ({I, 3),12)

In the following, we denote node Pi by i if there is no ambiguity. The generalized chordal ring (or simply, ring) on P with link configuration G will be denoted by the couple (G, N), where N = IP(. Given a ring C = (G, N), a fault pattern for C is a.set of integers F = {f~,f~, . . ., fm} where m 5 N and fj E [0, N). The set F C P represents the set of faulty PEs in C. The window IVF of a fault pattern F = {fl, f2,. . ., fm} (in ordered form) is the set of PEs between and including the first and the last fault in F. The width WF of a fault pattern F = , . . . , f,.,.,} is the size of W’F. The height {fl,fi hF of F is [WF/gk] - 1. Given a fault pattern F = { fi, f2,. . . , fm} in C, the cardinalization of F is C(F) = F + N .,f,+N-fi},whereall fi = {Wi+N-f,,.. operations are modulo N. Notice that the cardinalization of F is a translation of F by N - fi such that the first fault is 0 in the renumbered ring. Clearly, C(F) is in cardinal form if F is in ordered form.

000

000 Figure 2: A matrix representation work based on node 0

node for the matrix representation; we will denote this starting - node as the base node of the matrix representation. Assume that N = Lgk for some L. Definition 3 For a given ring C = (G, N), a base node b and a fault pattern F, we hefine’ the matrix form of C based on b, denoted by Mb(C), to be the Boolean matrix of size (L x gk) given by the following relation: Mb@%7 for

Definition 2 A fault pattern F is said to be blocking for ring C = (G, F) if F is in caminal form and catastrophic for linear army A = (N’, G) where N’ 2 N. A blocking fault pattern shown in Figure 1.

3

Representation

of a ring net-

d =

15 i 5 L,l

1 if((i-

0

otherwise

l)gk+j+b-

1) E F

5 j 5 gk.

In this representation, the node b is mapped into h!fb(c)[l, 11, node b + 1 is mapped into Mb(C)[1,2], and so on. For simplicity, when no ambiguity arises, in the following, we will use (i,j) to represent Mb(C)[i,j] as Well as the corresponding node in C.

for C = ({ 1,3}, 12) is

Example 1: Consider the ring C = ({1,3}, 12) with F = (3,5,7} as shown in Figure 1. The matrix form Mu(C) of C based on node 0 is shown in Figure 2. Given a node P in C and a matrix form M of C, let P = (i, j) in M; then we will use the following not.ation through out this paper: P(x) = i

of Ring

In this section, we will represent the ring in form of a Boolean matrix and establish various operations on this matrix relating to the renumbering of the nodes of the ring. Due to the wrap-around property of ring, we have to specify a starting 490

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

Proceedings of the 28th Annual Hawaii International Conference on SystemSciences - 1995

and P(y) = j. In most cases, we will need to represent ring C based on the first faulty node fi ofF = {fi,f2,...,fm}; th us, f or convenience, we call Mfl (C) the matrix of C based on F, denoted by MF(C). Definition 4 Given two L x gk Boolean matrices M and M ’, let t be a integer such that 1 5 t < N, we say M ’ is a left-shijt-rotate by t of M, denoted by M ’ = LSR(M, t), if M ’ = LSR(LSR(M, t l), l), where: M[i,

LSR(M,

l)[i,j]

= i

j + 11

M[l, l] M[i + 1, l]

ifj

1): L does not contain any wrap-around links; 2): for any node e in L, it will be below row s; that is, ije E L, then e(x) 2 s. Given a line segment L between p and q, let C?j = {e E L/e(y) = j} be the set of all the nodes in L which are in column j for 1 5 j < gk, we call the out-layer OL(L) of L is the set {el, e2,. . . ,egk}, where ej = mini{(i, j) E Qj}. Two line segments L1 and L2 are said to be non-crossing if L1 fl L2 = 0.

< gk

if i = L,j = gk otherwise

4

Similarly, we can also define the right-shijtrotate operation. Consider the matrix form of C based on a given minimal blocking fault pattern F = {ji, j2, . . ., fg,}. Let us denote the column coordinates of F by the ordered set {yi, ~2,. . . , yg,}. We have the following necessary condition according to [4]: Property 1 [4] For any minimal blocking fault . . . , fgk}, the following proppattern F = {fl,h, erty holds: there is exactly one fault in each column; that is, yi # yj for any pair of i and j such that 1 5 i, j 5 gk and i # j.

Problem

Reformulation

In this section, we will reformulate the problem of subring formulation in the context of matrix representation of rings. Fr} be a blocking decomposiLet {Fl,Fz,..., tion of F, where each Fi = {jil, ji2, . . . , jis,} Furtheris a minimal blocking fault pattern. more, without loss of generality, let us assume that fir = 0 and fii < f(;+i)i for 1 5 i < p. Let M be the Boolean matrix of ring C based on Fl. Due to the fact that each Fi is a minimal blocking pattern by itself, each Fi satisfies the CDP. Let us denote the row coordinate of fault in Fi on column j, 1 5 j 5 Sk, by x;j and also assume that ~ij < X(i+l)j for 1 < i < p, 1 < j < gk, which implies that Fi < F;+t. The ordering (Fi < Fi+l) ensures that Fi will appear above Fi+l in the corresponding matrix form M based on Fl. These p minimal blocking fault patterns partition C into p connected regions as shown in Figure 3 and therefore, each connected region is uniquely specified by two minimal blocking fault patterns. We denote the region specified by Fi and Fi+t by Si for i < p - 1; the region specified by Fr and Fl is S,. Regardless of the choice of the base node, one region (e.g., 5’s in Figure 3) will be split into two parts in the matrix representation. However, since each region is totally independent of the others in terms of connectivity, we can decompose the matrix into p independent regions and treat each region individually. Consider a region S specified by the Ft =

We will call this property the Column Distribution Property (CDP). For any given minimal fault pattern F = j,,,} which satisfies CDP, let xi be the {fl,fi,.**, row coordinates of the faulty node of F in column i, where 1 5 i 5 IJk, Now, we define the interior, exterior and border elements in M&C) for the window WF of F. Let a = (i, j) E WF, a is said to be an interior element if i < xj, a border element if i = xj, and an exterior element if i > zj, respectively. Now, for a given minimal fault pattern F satisfying CDP in C, the interior I(F), border B(F), and exterior E(F) of F, with respect to the matrix form of C based on F, are the set of all interior, border, and exterior elements, respectively. Definition 5 Assume that F = {Jo, j2,. . . , js,} is a minimal blocking fault pattern of C and M is a matrix of C such that Jo = (r, 1) for some T > 1. For any two non-faulty nodes p = (s, 1) and q = (S,gk) with s < r, a line segment L between p and q is a live path between p and q, which satisfies the following conditions:

{fil,fiZ,.

* *, fig,)

and

Fu

=

h,h,.

. .,

fugk),

where Fl < F,,. If f/i is not in the first column of

491

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

Proceedings of the 28th Annual Hawaii International Conference on System Sciences -

Figure 3: Three blocking fault patterns pose a ring into 3 regions

1995

G = { 1, gk}, which can be viewed as generating a lower bound on the size of subring for the general case. Regarding the relative positions of the two fault patterns Fl and F, in S, we use the term height of S defined below as a measurement. The height of S, denoted by Hs (or simply H), to be the number of rows of non-faulty nodes. To be preCiSe, H = L( jii - jUg,)/gk]. In this paper, we Will deal with the case when H > 2.

decom-

5

the matrix, we perform the so-called “normalization” of 5’with respect to FI. That is, we perform a series of shift-rotate operations which ensures that jii is placed in the first column. During the process of “normalization”, it is quite likely that the original shape of F,, in the matrix representation is distorted (i.e., jUi is no longer in the column where is used to be before the normalization). Clearly, we can also perform the normalization operation with respect to F,. In the rest of the paper, we will assume that S under discussion is always normalized with respect to FI. In building a subring in S, we are particularly interested in the size IC’I of C’ we built. Clearly, there is an upper bound for IC’I , that is, IC’I 5 15’1. We denote the subring generated by a reconfiguration algorithm A by C’(d). For any given subring generation algorithm A, we define a node P E S to be a missed node of A as follows: Definition 6 For any node P E S, P is said to be a missed node of a subring generating algorithm A if P 6 C’(d).

Strategy

for Ring

Formation

AlI the algorithms developed in this paper use the notion of line segment introduced in the previous section. The idea is that we try to appropriately divide S into three parts, namely the upper part, the lower part and the middle part. If the middle part is large enough, we can construct a set of line segments in both the upper part and the lower part respectively, and use the middle part to connect them to form the ring. This scheme, called LSRF (line segment ring formation), consists of the following four steps: Step 1: Decompose S into three parts S,, SI, and S, appropriately. Intuitively, S consists of three parts: 5’~” = SnwF,, SF, = S~IWF, and MS = S-SF,, -SK; that is, MS = {(i, j)l(r’,s’) < (i, j) < (r, 1)) with respect to the lexicographical ordering. (Recall = ji,,(y),r’ = fusk(z) and s’ = that r = jii(x),s jug,(y)). Since H > 2, lMs/ > 3gk. For any decomposition of H = h, + h, + ht where h’s are positive integers, we can further divide MS into three subsets as follows: M,, = {(i, j)l(i, j) 5 (r’+h,,s’)),Ml = {(i,j)l(r-h, 1) L: (i,j) 5 (r1, gk)} and S, = MS - MU - Ml; accordingly, we can divide S into three parts, namely: the upper part S, = SF, U M,, , the lower part Sr = SF~ U Ml and the middle part S,. A decomposition of S is illustrated in Figure 4 with H = 6, h, = 2, h, = 1, hl = 3.

Consider two link configurations Gr and Gz for the same number of nodes N and assume that G2 C Gr. In terms of the subring generation algorithms in S, we have the following observation. Property 2 Let G2 g G1, A be a subring genemtion algorithm for S in C:! = (Gz, N), then A is also a subring genemtion algorithm for S in C1 = (Gl, N). In particular, a subring genemtion algorithm for S in ring ({ 1, gk}, N) is also one for S in ring ({l,gz,. . .,gk},N).

Step 2: Form a set of non-crossing line segments in 5’1 and S,, respectively. Recall that S is normalized with respect to FI; thus, in !$I, Fl has the following characteristics: 1) the faults in the first column and in the last column are always in the same row, say row r; and

In this paper, we will focus on the development of subring generation algorithms for the case of

492

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

Proceedings of the 28th Annual Hawaii International Conference on System Sciences - 1995

8 8 88-8 8 8 #@.$‘8 0000@‘00’a00~a000 00000~e00000000 f F,

to nodes in S,, we can finally use the nodes in S, to connect the two lines to form the ring. The following terminology will be used throughout this paper. Given S, let F = {fi, f~, . . . , fsk} be a blocking fault pattern of S, for any i, if fi + 1 E S, and fi+i - fi - 1 is odd, then we say F has an odd-opening. We define the & of F, odd(F), to be the total number of odd-openings of F. We denote odd(S) to be odd( 4) + odd( F,). For simplicity, we will denote the fault pattern in 5’1 by

8

Figure 4: Divide 5’ into S,, S,, and SI

Figure 5: Illustration

of transferring

F=

{f1,f2,-.,fg~}.

6

Line Segment gorit hm

Formation

Al-

Assume for the moment that there is an unbounded number of non-faulty rows above row T in Sl. This assumption is only made to simplify the presentation and will be lifted later. For a given node P = (i,j), its neighbor below B(P), neighbor above A(P), right neighbor R(P) and left neighbor L(P) are nodes (i t l,j), (i l,j), (i,j + l),(i,j - l), respectively. Similarly, for a given set of nodes D, its neighbors below B(D),- neighbors above A(D), right neighbors R(D) and left neighbors L(D) are the set of nodes uwYp E DNw)Ip E D)7{WP)IP E D}, {L(P)IP E D}, respectively. Notice that in Sl, if a non-faulty node is surrounded by three faulty neighbors, it will be impossible for any subring generation algorithm to include it in the resulting ring. For a given fault pattern F, a non-faulty node P E A(F) is a singleton of F if L(P), B(P), R(P) E F. We will denote the set of all the singletons of F by SGT(F). It is clear that no singleton can appear in the middle of a line segment since its degree is only one once we remove all its links to the faulty neighbors. A node is said to be connectable if it is neither a faulty node, nor a singleton. It is said to be a non-connectable node, otherwise. For a node P, the connections from P to R(P), L(P), B(P), A(P) are the right connection, left connection, down connection, and -up connection, respectively. Given a minimal blocking fault pattern F and sl, for any 1 5 u 5 HF + I, let i = f + HF -

S,

2) all the faults of Fl are located in or below row T. Based on this property, an algorithm to form a set of non-crossing line segments is developed. Due to the existence of S,, we can view SI and S, as two separated entities in terms of line segments formation. Furthermore, we can always translate S, by the shift rotate operations so that F, has the following properties: 1) the faults of F, in the first column and in the last column are in the same row, say row T’; and 2) all the faults of F, are in or above row T’ (see Figure 5). In other words, the scheme developed for Sl apply symmetrically to S,, by using the counter-clockwise orientation. Thus, without loss of generality, we will consider 5’1 in the rest of the discussion. Step 3:Connect the line segments to form a single line in ,!?I and in S,, respectively. A unique line L is formed by connecting all the line segments formed in SI in Step 2 such that the two end nodes of L have links to nodes in S,. A unique line is formed in S, analogously. Step 4:Use S, to connect the two lines formed in Step 3 to form a ring. Since the two lines formed in Step 3 have links

493

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

Proceedings of the 28th Annual Hawaii International Conference on System Sciences -

u + 1 and Nij = {(i,l),(i,I+ 1) ,..., (i,l t d)} be a cluster of non-faulty nodes in Ri. Consider the straight line between (i - 1,l - 1) and (i 1,l + d + 1); we can extend it with an operation called CB (cluster bounce) with the last u rows from column 1 - 1 to column 1 f d + 1, denoted by CB(v, 1, d, F). More precisely, the CB operation can be formally given as follows, where P3 = (i - 1,j).

of minimal blocking fault pattern, we know that L(P), B(P) E F; furthermore, if B( R( P)) is connectable, we can conclude that we have encountered a cluster of Ri; otherwise, we repeat this process with R(P) as the new current node. The Algorithm FBB can be formalized as follows: Algorithm FBB: Follow the border and bounce INPUT: F and u OUTPUT: A line segment Begin L - 0 /* assume no segment */ i=r+Hp-u current-node P + (r - 1,1) While P(y) # gr; do /* scan until last row */ If P(z) = i - 1 then While B(R(P)) is non-connectable do add P to L /* keep current element */ P - R(P) /* look right */ Endwhile

CB: Cluster Bounce INPUT: u. 1. d and F OUTPUT: a line segment Begin L + 0 /* assume no segment */ For j = -1 to d + 1 add PI+, to L if j is even then P - B(P) / * look down */ While B(P) @ F /* keep going down */ add P to L /* keep current element */

Q - FindNeztEnd( P, F) add CB(C P(Y), Q(Y),F) -

P 6 B(P) Endwhile if R(P) @ F then /* keep right element */ add P, R(P) to L /* keep current element Endif P + A(R(P)) /* now move up */ While P # P,+I do add P to L /* keep current element */ P - A(P) /* keep moving up */ Endwhile Endif EndFor return L End

1995

tQ1 to L

P-Q Endif add P to L If B(P) is connectable then add B(P) to L /* keep down element */ P - R(B(P)) /* look at the right of that */ If R(P) is connectable then P - R(P) /* look at down element */ If A(P) is connectable then add A(P) to L /* keep up element */ P +- R(A(P)) /* look at right of up element */ Endif Endwhile add P to L /* keep current element */ output L End

*/

Observe that if u = 1 then i = T + HF. Since fg,(x) = T + HF, then Ri = 8. Thus, there is no CB operation at all; or, in other words, CB( F) = 8. Also observe that if u = HF+l then i = T; that is, the CB operation will connect nodes starting and ending at row T - 1. For any given 2 5 u 5 HF, we can use the CB operation to obtain the FBB (follow the border and bounce) algorithm. The main idea is that for the connections between row T - 1 and row i - 1, we use a “follow the border” approach. For the connections below row i - 1, we use the CB operation on each cluster of non-faulty nodes in row i. For any pair of inputs u and F, we use the following scheme to detect the occurrence of a cluster of non-faulty nodes: once the current node P is on row i - 1, according to the property

Function FindNextEnd(P, F) finds the next end point for CB; that is, if f is the next faulty node of F in row i from column P(y), it returns 4f

1. A new line segment generation algorithm FBBS is formed by repeatedly using FBB with an appropriate u at each iteration. For any given h >_ 1 and a minimal fault pattern F, let ~1, uz, . . . , uh be a set of integers where 2 5 u; 5 HF + 1, and C; ui = h t HF, we can describe FBBS as follows: Algorithm FBBS: INPUT: h, UI,UZ, . . , t‘h, F OUTPUT: A set of non-crossing Begin

494

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

line segments

Proceedings of the 28th Annual Hawaii International Conference on System Sciences - 1995 L+B For i = 1 to h do

L + FBB(u,, L F + OL(L)

F)

output Endfor End

Notice a very interesting situation for FBBS when h = HF and ui = 2, 1 5 i 5 h. In this case, we only apply the bounce technique to the last row; so we call this type of FBBS algorithm the “bounce to the last row only”, or simply the BLRS. Theorem 1 For each odd-opening of F, there will be ezactly one missed node and there is no other missed node for Algorithm BLRS; that is, Im(BLRS, F)I = odd(F). Clearly, if h 2 HF, Ui = 2 is the best choice for FBBS. If h < HF, this set of ui’s is not a valid choice for FBBS. In this case, we can take any valid combination of ui’s for FBBS. For simplicity, we choose ~1 = ‘112= . . . = u&l = 2, and uh = HF - h i- 2. That is, we apply the Algorithm BLRS for h - 1 iterations and then apply SB to the last iteration. A similar variation of the above scheme is the following: we apply FBB with u = HF - h + 2 for the first line segment, then we apply B L RS for the remaining iterations.

7

Ring

5’1. By “top of all the line segments” we mean that, if fi = (T, 1) and there are h line segments, the two end points for the line are both on row T - h. When constructing this line, we want to keep the structure of the line segments as much as possible while including in the resulting line all the nodes of these line segments. Let the n line segments be L1, L2,. . . , Lh and each Li have di elements, say Li = {PiI, Pi27 . . ., Pi&}. Without loss of generality, assume that PiI > Pjl(Z) if i > j. Since the end points of the resulting line have to be on row r - h in SI, we have to start and end the resulting line at line segment LI; thus, it is impossible to completely keep the structure of L1. Without loss of generality, we choose the first node P from the left in L1 as one end point of the resulting line. To construct this line, we start from P and perform the following tasks: connect all the nodes in the first column; go along Lh until the last column is reached; connect the last node in L&i; then go along Lh-i in reversed order until the node in Column 2 is reached; connect the line Lh-2 on Column 2 and go along L,,--2; and so on, until all the elements in L1 is included. Algorithm LFORM: INPUT: LI, Lz,. . . ,Lh, where L, = {P,,,P,z, . . ., Pid,} OUTPUT: a line L Begin For i = 1 to h do add P,I to L Endfor For i = 2 to dh do add P,,, to L Endfor j-h-1 While j > 0 do If (n - j) is odd then For i = d, to 2 do add P,, to L Endfor Else For i = 2 to d, do add P,, to L Endfor Endif decrement j Endwhile output L End

Formation

In this section, we present an algorithm to connect the line segments to form a line in SI and in S,, respectively, and finally to connect the two lines to form a ring by using S,. Observe that, once we applied the shift rotate operations in S,, the line segments formed in S, will be similar to those in S1; thus, we can develop common algorithms as described in the following. 7.1

Connecting Line in S,

Line

Segments

to

a

In this section, we present an algorithm to connect the set of line segments, produced by any line segments formation algorithm described before, to form one line in 5’1, such that both its end points are on the top of all the line segments in

Example 2: In Figure 6, we show the result of Algorithm LFO RM with some line segments produced by BLRS. In this example, we use dashed

495

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

proceedings of the 28th Annual Hawaii International Conference on System Sciences - 1995

Figure 6: Illustration LFORM

of the result of Algorithm

lines to represent the line segments and for the resulting line. Notice that in Algorithm LFORM, if then the two end points of the resulting be (r - h, 1) and (r - h, 2); otherwise, be (r - h, 1) and (r - h,gk). 7.2

Connecting the Form A Ring

Three

solid line h is even,

line will they will

Parts

to

end points of L will be either (T’ + h, + 2,1) and (rtth,t2,2)or(r’f~,+2,1)and(~‘+h,+2,gk). Let us now consider the problem of choosing the appropriate decomposition of H. A very important observation is that, in Step 1 of the subring formation algorithm, we can choose h, = 1 to improve the performance of Step 2, without degrading the performance of Step 4. That is, it is possible to decrease the number of missed nodes in SI and in S, by increasing ht and H,, respectively. In general, if H 2 HF~ + HF, •i- 1, then we will choose h, = HF, , ht = HF, , and h, = H - hl - h,. Without loss of generality, let us assume that h, = 1. Denote by P,Q and P’,Q’ the two end points of L and L’, respectively, where P = (T’ + h,$2,1),P’= (Ttthwst), Q = (T’+ h,t2,2) and or (T'+ h, t &gk), (r’+h,,s’-

Recall that H = h, + h, + ht. For any specific decomposition, the two end points of the line L formed by Algorithm LFO RM in Sl are: (T ht, 1) and (r - hl, 2), if ht is even; and (r - ht, 1) and (r - ht,gk), if HF~ is odd. Similarly, for S,, by applying L FO RM in S,, we get another line L’. Let fUSk = (T’, s’), where T’ = T - H - 1; then the two end points of L’ are: (T’ + h,, s’) and (T’ + h,, s’ - 1)) if h, is even and s’# l;(r’+h,,s’)and(r’fh,-l,gk),ifhuiseven and (r’+h,-l,s’+l),ifh, andj = 1; (r’fh,,s’) is odd and s’ # gk; (T' $ h,,s’) and (T' t hu,gk), if h, is odd and j = gk. The main objective in this section is to form a ring by connecting the end points of the two lines L and L’. The major concern is to include as many nodes from S, as possible and maintain the structures of L and L’. If h, > 1, we have h, complete rows of nonfaulty nodes in S,, which are row T’ + h, $1, T' t T - ht - 1. We can always reduce this h,+2,..., case to one of the cases for h, = 1 by extending one of the two lines, say L, in a fashion similar to the one used by Algorithm LFO RM. That is, on Column 1, we can connect (T’ + h, + 2, l), (T’ + (T - ht - 1,1) to (T - ht, 1); on the hut&l),..., other end, by using Column 2 and Column gk, we can connect all the remaining nodes in row T’ + h, + 2,. . . , r - ht - 1 to L at the other end point of L. Clearly, after this extension, the two

Qt

=

1) -

l,!i’k)

(T’t

hu

(T’ +

h, - 1, s’ + 1)

1 (T’ t hu, 1)

if h, is even; s’ # 1 if h, is even; s’ = 1 if h, is odd; s’ # gk otherwise

It is clear that there are exactly eight different cases depending on the positions of Q and Q’. Case 1 Q = (r’ + h, + 2,2), Q’ = (T’+ h,, s’ - 1) Cc L = {P,...,Q} add A(Q), R(A(Q)), . . , B(Q’) to C toC add L’-{P’}={Q’,...,P’}-{P’} add P’ to C T * P’ While T # (r’ + h,, gk) do add B(T), R(E(T)), R(T) to If R(T) # (T’+ h,, a) then add R(R(T)) to C

C

T - R(W)) Else

S + R(T) Endif Endwhile add A(P) to C

Case 2 Q = (r’ + h, + 2,2), Q’ = (r’ + h, - 1, s‘ + 1) with s’ # gk

C+- L = {P,...,Q) add A(Q), R(A(Q)), . . , B(P’) to C add L’= {P’,...,Q’) toC add

B(Q’)

to C

B(Q’)

T -

While add

T # (r’ + h,, gk) do B(T),

R(B(T)), R(T) to C

If R(T) # (7’ + h,, add

496

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

R(R(T))

gk)

to C

then

Proceedings of the 28th Annual Hawaii International Conference on System Sciences -

1995

T + R(W)) Else

T + R(T) Endif Endwhile add A(P) to C Case 3 Q = (r’ + h, + 2,2), Q’ = (r’ + h,, 1) C+L={P,...,Q) add A(Q), R(A(Q)), . . , B(P’) to C add i’ = {P’, . . , Q’) to C add B(Q’) to C Case

4 Q = (r’ + h, + 2,2),

C+L={P,...,Q) add A(Q), AtA( T - AtA(

Q’ = (r’ + L

Case 1

Case 2

Figure 7: Illustration

pf$fqf

T c R(T) add T to C Endif While T # (r’ + h,, gk) do add B(T), R(B(T)), R(T) to C If R(T) # (r - HF, -hl,gk) then add R(R(T)) to C

and Case 2

case4 Figure 8: Illustration

of Case 3 and Case 4

R(W)) add

T + R(T) Endif Endwhile add L’ = {Q’, add A(P) to C

then

T + L(T)

, P’) to C

5 Q = (r’ + h, + 2, gk), Q’ = (r’ + h,, s’ - 1) with C+L={P,...,Q) add A(Q) to C

Endif While T # B(Q’) do add B(T), L(B(T)), L(T) to C If L(T) # R(B(P’)) then add L(L(T)) to C

s’ # 1

T Else

T - A(Q) While T # R(B(P’)) do add A(T), L(A(T)), L(T) to C If f,(T) # R(B(P’)) then add L(L(T)) T - L(V))

A(Q), A(A(Q)) to C

T + AtA( If T # B(Q’)

case

T + L(T)

to C

8 Q = (r' + h, + &gk), Q’ = (r’ + h, - l,gk) C+L={P,...,Q) add A(Q), L(A(Q)), . , B(R(P’)) to C add R(P’),R(R(P’)), . . . , B(Q’)) to C add L’ = {Q’, . , P’) to C add A(P) to C

to C

The cases are Gstrated in Figure 7, Figure 8, Figure 9, Figure 10. Notice that in the worst case, we may miss up to 1 node in S, in Cases 1, 3, 4, 5, 7. In Cases 2 and 8, we do not lose any; in Case 6, we lose the node Q = (T’+ h, + 2, gk). Thus, we have the following result:

Case6Q=(r’$h,+2,gk),Q’=(r1+h,,1)

C - L = {P,. . . . Q) - {Q) add A(L(Q)), L(A(UQ))), . . . l BtQ’) add LI = {Q’, , P’) to C add B(P’) to C

to C

7 Q = (r’ + L + 2,gk), Q’ = (2’ + h, - 1, s’ + 1) with

to C

case

T + L(T) Endif Endwhile add B(P’) to C add L’ = {P’, , Q’) to C add B(Q’), L(B(Q’)), . , A(P)

4W))

Endif Endwhile add t’ = {Q’, , P’) to C add B(P’),L(B(P’)), . ,A(P)

Else

Case

1

fg+Q

to C

If T # (7’ + h,, gk) then

T Else

of Case

- 1, gk)

3’ # gk

C+L={P,...,Q)

Theorem

2 For any given S, the number

497

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE

of

Proceedings of the 28th Annual Hawaii International Conference on System Sciences - 1995

ers, Vol. C-30, No. 4, April 295.

C&SC?5 Figure 9: Illustration

Case 6

1981, pp. 291-

PI

D. Z. Du, D. F. Hsu, and F. K. Hwang, “Doubly Linked Ring Networks”, IEEE Trans. on Computers, Vol. C-34, No. 9, Sept. 1985, pp. 853-855.

PI

H. Masuyama and T. Ichimori, “Tolerance of Double-Loop Computer Networks to Multinode Failures”, IEEE Tmns. on Computers, Vol. C-38, No. 5, May 1989, pp. 738-741.

of Case 5 and Case 6

PI A.

Nayak, L. Pagli, and N. Santoro, “Efficient Construction of Catastrophic Patterns for VLSI Reconfigurable Arrays”, Intergmtion - the VLSI journal, Vol. 15, No. 2, Oct. 1993, pp. 133-150.

Case 8 Figure 10: Illustration

I51A.

Nayak and N. Santoro, “Fault-Tolerance Analysis of Redundant Ring Networks”, Pmt. Int’l Conf. on Pamllel Computing, London, 1991; in Advances in Parallel Computing, Vol. 4, North-Holland, 1992, pp. 311-322.

of Case 7 and Case 8

missed nodes in the subring formed by using the LSRF scheme with any of the line segments formation algorithms is at most gk + 1.

8

PI A.

Nayak, N. Santoro and R. Tan, “FaultIntolerance of Reconfigurable Systolic Arrays”, Proc. 20th Int’l Conf. on FaultTolerant Computers, Newcastle upon Tyne, June 1990, pp. 202-209.

Conclusions

In this paper, we have developed a set of algorithms for forming a subring in a given region S. They all follow the same general strategy of first decomposing 5’ into three parts (upper part, middle part, and lower part), then forming line segments in both upper and lower parts, and finally connecting the line segments with the help of the middle part to get a ring. The number of missed nodes for all the algorithms is gk + 1 in the worst case. The line segment formation algorithm has time complexity O(g$YF). Other variations of this algorithm are reported in [9]. The subring formation algorithms presented in this paper are optimal in the sense that they minimize the number of possible misses. It should be stressed that for any given S, the problem of determining the largest possible subring in S is NP-hard.

VI C.

S. Raghavendra, M. Gerla, and A. Avizienis, “Reliable Loop Topologies for Large Local Computer Networks”, IEEE Tmns. on Computers, Vol. C-34, No. 1, Jan 1985, pp. 46-55.

PI

J. Tyszer, “A Multiple Fault-Tolerant Processor Network Architecture for Pipeline Computing”, IEEE Trans. on Computers, Vol. C-37, No. 11, Nov. 1988, pp. 14141418.

PI

Q. Xue, “Reconfiguration of Chordal Ring Networks,” M. C. S. Thesis, Carleton University, Ottawa, Canada, 1994.

References [l] B. W. Arden and H. Lee, “Analysis of Chordal Ring”, IEEE Trans. on Comput-

498

Proceedings of the 28th Hawaii International Conference on System Sciences (HICSS'95) 1060-3425/95 $10.00 © 1995 IEEE