PROJETO DE ALGORITMO PARA EXTENSÃO K-TOLERANTE A FALHAS DE GRAFOS CIRCULANTES

-1m

,

OJ,DOD1.0UD1.D1.1.1.0UJ.OW1.1.0000101.DUJ.ODl.OJ.OJ.OOOJ,001.0UDO),OOOlO11.01.01uaU),OlOUOOD010J,OU1.OOJ.01.01,ODOJ.OO1.0),),OO1.0D010U01.0J.UO],},),OlOUOODOJ,Ol,DUlOO1.0J.OJ,OOOJ,OOJ.OUOD1.DOO1.0UOJ.01.01.UOO1. . o),] U01.0UOOD01.D1.0J.UD01.01.01.0DOJ,001.0),),OOJ,OOUO),),OlOl,),],01.UOJ,OJ,l,DDOO1.010U10D1.0J,OJ.ODOJ,OOJ,OJ,J.OOJ.00010),),OJ.OJ.U01.),),01.0UOOOOJ.OJ.O),J,),OOJ,D:I.OlOD01DOJ.O],],OOJ.OOOJ.01.1.001.0100J.OJ.OOOOO1.0J.O],1,1.DOJ.01.0I A r t 1 9 o ~~D)'O

PROJETO DE ALGORITMO PARA

EXTENSÃO K-TOLERANTE A FALHAS

DE GRAFOS CIRCULANTES

ALGORITHM PROJECT TO EXTENSION K- TOLERANT

FAULT OF CIRCULANT GRAPHS

Leandro Gallinari

leandrogallinari @terra.com.br

Michael Damico

michael.damico@ uol.com.br

Tales Pinheiro de Andrade

[email protected]

Orientado

por

Luiz Carlos da Silva Rozante

IMES

-

Universidade Municipal de São Caetano do Sul [email protected]

li

,

J,oa01.OU01.O),),),01.U010UOOOO1.01.01.1.J.OO),OlOJ.OIJOJ,OOJ.OUOO1.000),OU01.OJ.U01.1,1.01.O),),OOOO1.01Q),),),OOlOlOlODD1.00),OUDOJ.OOD1.DUOJ.O),),),0),],},010),),0. .. Dac ),),01.01100001.01.01.1.1.001.01.01.0001.001.01.1.001.0001.01.1.01.01.1.1.0111.01.01100001.01.01.1.1.001.01.01.0001.001.01.1.001.0001.01.1.01.01.1.1.01.1.1.01.01.1.00001.01.0111.001.01.01.1Rev 1sta de In f armát 1ca Ap11cada h1Q.[

r

I

Artigo

1. INTRODUÇÃO

Este trabalho se baseia no artigo de Farrag, [1996], quedescreve uma forma muito eficiente de geração de extensões k-tolerante a falhas. Iremos descrever detalhadamente o funcionamento desse procedimento e,em seguida, descrever algumas formas de melho-rara complexidade do algoritmo, além de modificá-Io paramelhorar sua performance.

O artigo está dividido em quatro seções. Além desta primeiraseção, contendo a introdução, na seção 2 des-crevemos o problema de forma geral, apresentando diversosconceitos necessários para a compreensão da soluçãoproposta por Farrag, além de apresentar uma descriçãosimples e direta dessa solução. Na seção três, apresentamos a técnica de forma detalhada, demons-trandoo pseudocódigo de forma completa e analisan-dosua complexidade, a partir da complexidade de cada parte interna do algoritmo. Por fim, na seção quatro, damos uma conclusão, além de sugestões para

traba-lhos

futuros, baseados neste texto.

Diversaspesquisas são desenvolvidas na área de

processamentoparalelo. A computação paralela

re-solve,de forma mais rápida, diversos problemas, como

mapeamentogenético, simulações climáticas e

con-trolede trafego aéreo, reduzindo muito o tempo

re-queridopara a solução de um problema.

Podemosclarificar,de forma bem simplista,a

com-putaçãoparalela em duas categorias, quanto a sua

necessidade:como primeiro caso, podemos citar a

necessidadede encontrar a solução para um

proble-mao mais rápido possível; o segundo caso seria

re-solver um problema

em um tempo máximo

predeterminado.Na primeira categoria estão

proble-masonde a solução na computação comum levaria,

emalguns casos, até centenas de anos, como

deci-frarseqüencias genéticas, simulações climáticase de

reaçõesquímicas e decodificação de sinais de rádio

detelescópios.

Nossotrabalhose aplica,principalmente;ao

segun-docaso. Comoexemplo de aplicação, podemos citar

computadoresmultiprocessados que efetuam

contro-lede tráfegoaéreo. Nessetipo de sistema, não adianta

dara resposta em um tempo que tenda a zero, mas é

críticoque ele responda em um tempo suficientepara

evitarum desastre. Assim,é possívelprojetar um

sis-temaque forneça a resposta antes de um tempo

pre-determinado.Seessa resposta vierantes, não irágerar

nenhumproblema. Porisso, é necessário atribuir

pro-priedadesde tolerânciaa falhas nesses sistemas, com

a inserção de novos processadores, por exemplo.

O sistema se tornará mais rápido, porém será tam-bém mais seguro.

Além disso, muito do que está descrito neste tra-balho é essencialmente escrito em termos da teoria dos grafos, podendo, portanto, ter utilizações além das inicialmente pensadas.

2. DESCRiÇÃO DO PROBLEMA

Diversas técnicas de extensões k-tolerante a

fa-lhas foram criadas. Dentre elas, podemos citar Farrag, [1995], Dutt [1990], Wu, 2000, Banâtre et aI. [1989] e Lee and Wang [1995]. Uma técnica muito eficiente chamada particionamento em distâncias m foi defini-da em Farrag [1996].

Vamos descrever detalhadamente e implementar

o algoritmo para particionamento em distancias m

para o projeto de uma extensão k-tolerante a falhas de um grafo circulante. Para que possamos iniciar, vamos, primeiro, definir alguns conceitos que serão utilizados ao longo do texto.

Definição 1 Grato circulante

Umgrafo circulanteé um grafo G(V,E) de n

vérti-ces, onde existe pelo menos um ciclo no qual podem

ser embutidos todos os vérticesde V, no qualo i-ésimo

vértice é adjacente ao (i+a.(mod n))-ésimo e ao

_J

(i-a.(mod n))-ésimo vértice, para todo a. em um conjun-J J

to A, para 1~ aj~

[-9-],

1~j~ [-9-],

para 1~ i~

[-9-]

[Weisstein, 2000], [Farrag, 1996].

Os elementos do conjunto Aserão denotados como

offsets, [Farrag, 1996].

Definição 2 Offset

Estando os vértices do grafo circulante dispostos simetricamente e de forma eqüidistante ao longo de uma circunferência, um offset a é o número de arcos entre os vértices que estão no arco menor formado por uma corda entre dois vértices x e y mais 1, se a ~[-9-]

, caso contrário, a = n - a. Assim, podemos

dizer que no grafo circulante, dois vértices x e y são unidos por uma aresta, se e somente se, existe um offset ai tal que se x e y são vértices numerados do grafo circulante, então ai = (x - y) mod n [Farrag, 1996],

[Dutt and Hayes, 1991 ].

Exemplo 1 Considere um grafo de 15 vértices e o

conjunto A = {I, 3, 5}. A Tabela 1 mostra suas adjacências.

11I

Q .. 0100010 nUlo},},10U1.01.0UOQOO1.0J.01.UOOJ.OJ.01000J.OO1.0U001000101.1.D 10 lU01.1.1.010J. 1000010 1.01.1.1.00101.0lODO1.0010U001000 1.0nUlO U 101.],101.0 11.0010U0001

RIm

,

OlDDD1.DU0101UOU101>D],lOOOD1DlOU1DDlOlOJ,ODD1,OOlOU.OOJ.00010),J.OJ.OU10U1D101],DOOD1DJoOU1.D01.0101,OOD1,DOJ.Ol10D10DOlOUOJ.D1U,OJ.lJ.010U0000101DU1001,010100DJ,DD10U0010001DU010101UOD1 _{I Ar t} 10uI A t' I'LOOO

1

.

9O ~O)'D r 19o nOlO

1.101.0U000010),0),),100101.01,0001.0010),1001.000101},010),),10),),},01.0),],00001010),1,100),01010001.0010110D1.000101101.01),),01),),010),],000OJ.01.0U1D01,OJ,O),OOQ),OOJ.O},J.OD10QOJ,011.00J.01001D1.000001010U1001010 U

Tabela 1: Cálculo da adjacência dos vértices de um grafo circulante G [1, 3 ,5: 15]. Todos os valores estão em (mod n).

o grafo circulante Gserá denotado por G [a" a2,...,

an:n], onde O < i < [1-],A = {a" a2,..., aJ, é o conjunto

de offsets e n é o número de vértices no grafo G.

Devidoà simetria do grafo circulante, neste artigo

tomamos como o número máximo de offsets de um

grafoo valor

[1-] ,ou seja, 1 ~ IAI~ [1-],e ai ~ [1-],\j ai E A. Devemos notar também que se substituirmos um offset ai pelo offset n - ai(ou por- a), o grafo terá exatamente as mesmas arestas. Por isso, se um offset

a. for calculado e não estiver nessa faixa de valores,, este deverá ser convertido para o seu offset equiva-lente dentro da faixa 1 ~ ai ~ [1-], isto é, se a é um

offset e a >[1-], então a = n - a mod n.

Definição 3 Extensão k -ft

Um grafo G' é dito ser uma extensão k-tolerante a falhas (ou k - ft) de um grafo G se para cada subcon-junto F de no máximo k vértices, o grafo G'

-

F que é

obtido removendo-se os vértices em F de G' deve con-ter um subgrafo isomórfico à G.

Agora que já temos alguns conceitos, vamos co-meçar a explicar o algoritmo, lembrando que nosso problema consiste em, dado um grafo G e um inteiro

k, determinar a extensão k-tolerante a falhas de G.

Seguindo a Definição 3, a idéia básica da geração de extensões k-tolerante a falhas é adicionar ao grafo G um conjunto 8 de vértices sobressalentes, sendo 181= k, isto é, um conjunto com kvértices, de modo a

formar um novo grafo H. Assim, removendo-se um conjunto F de vértices de H, onde F representa o conjunto de vértices falhos, sendo 1 ~ IF I ~ 18 I, o grafo I resultante da remoção dos vértices falhos será isomórfico ao grafo G.

Para que o novo grafo Hseja uma extensão

k-toleran-te a falhas do grafo G e para que a extensão

k-tolerante a falhas seja eficiente, algumas propriedades [Dutt and Hayes, 1991] devem ser satisfeitas. São elas:

1. Baixa redundância, isto é, o número de vértices e arestas sobressalentes deve ser reduzido o máximo possível.

2. Reconfiguração rápida, incremental e distribuí-da. A reconfiguração incremental é a capacida-de do sistema capacida-de se reconfigurar em caso capacida-de novas falhas, sem a necessidade de desfazer con-figurações para contornar falhas anteriores. Já a reconfiguração distribuída, é necessária para per-mitir que diferentes partes do sistema falhem e se reconfigurem concorrentemente, sem a

ne-cessidade de um controlador central para

reconfiguração.

3. Projeto incremental, o que permite projetar um sistema com alta tolerância a falhas a partir de um sistema comum, sem grandes custos. 4. Amenabilidade para sobressalência local, isto

é, a diminuição ao mínimo da necessidade de ligações e processadores sobressalentes. Assim, foram criados alguns métodos para proje-tar extensões k-tolerante a falhas que atendam esses requisitos.

Um método básico consiste em adicionar os vérti-ces usando o Teorema 1, [Farrag, 1996]:

Teorema 1 Seja um grafo circulante G [aI' a2, ...,

an: n], nós podemos construir um grafo circulante H com (n + k) vértices que é uma extensão k-tolerante a falhas de G,onde o conjunto A de offsets de H consiste da seguinte união:

{aI'

a

I+ 1, aI+ 2, ..., aI+ k} U {a2'

a

2+ 1, ..., a2+ k}

U...U {a., a. + 1, a. + 2, ..., a. + k}.I I , I

Porém, uma extensão

k-tolerante

a falhas

construída de acordo com o Teorema 1 só será

efici-ente em relação ao grau dos vértices (conseqüefici-ente-

(conseqüente-mente ao número de arestas que deles saem) se os

offsets de Gforem consecutivos, isto é, tenham a

for-ma {a, a + 1, a + 2, ...}.Podemos visualizar isso

atra-vés dos seguintes exemplos.

Exemplo ~ 1 3], mostrad grafo G, seri€< 1 da seguintE {l,l+l,l, A extensão H [1,2,3,4: Figura 1:Um gr Figura 2: A saiu Vértice

_l==f

_{Ji::3 J ...} i _{1+} i j .i-f-J 1 ;) lil+-} ij}

_j

O 1 14 3 12 5 10 1 2 O 4 13 6 11 2 3 1 5 14 7 12 3 4 2 6 O 8 13 4 5 3 7 1 9 14 5 6 4 8 2 10 O 6 7 5 9 3 11 1 7 8 6 10 4 12 2 8 9 7 11 5 13 3 9 10 8 12 6 14 4 10 11 9 13 7 O 5 11 12 10 14 8 1 6 12 13 11 O 9 2 7 13 14 12 1 10 3 8 14 O 13 2 11 4 9

imes

Exemplo 2 Considere o grafo circulante G [1, 2:

13], mostrado na Figura 1. Uma extensão 2-ft do grafo G, seria construída de acordo com o Teorema 1da seguinte forma:

11, 1 + 1, 1 + 2} U {2, 2 + 1, 2 + 2} = {l , 2, 3, 4}

A extensão 2 -ft de G [1, 2: 13] seria o grafo

H[1, 2, 3,4: 15] exibido na Figura 2.

Figura 1: Umgrafo circulante com n

=

13 e A = {1,2}.

Figura 2: A solução 2-tolerante a falhas do grafo da Figura 1.

Exemplo 3 Agora, se considerarmos o grafo

G [1, 3: 13], sua extensão 2-ft será gerada da

seguinte forma:

{l, 1 + 1, 1 + 2} U {3, 3 + 1, 3 + 2}= {1, 2, 3,4, 5}

sendo então o grafo H [1, 2, 3,4, 5: 15].

Figura 3: Umgrafo circulante com n

=

13 e A = {1, 3}.

Figura 4: A solução 2-tolerante a falhas do grafo da Figura 3.

Im

A

O:l.OOO1.0U010),],J.O),),],0),OUOOOO1.01.0),],).00101010001.0010],),00100001O],),01.0J.UDUJ.OJ,O],),ODD0101DUJ,OOlO1.01.0D0100).OUOO1.0001011DlOU101.U010UOOD01.0J.OUJ,OD1D10J,OOOlOD10),},C01.0D010],],010J.OU1Dol

l Ar t1

.

_gO 1311!!t~1 1.101.01.10000).0101.101.0010),010001.001011001.000].01101.01.),1011101.DUOOOD1D10),),),00101D1D0010010U0010DO).OJ.J,O),OU1DJ.),J.OJ.O],],OOD010101UOOJ,Ol01D0010010UOO1.0001.CU0010J.OOJ,OlODOOO),O),011),00101.0b.~

Podemos perceber que o método do Teorema 1 gera arestas desnecessárias na extensão k-tolerante a falhas para conjuntos de offsets não consecutivos.

Conforme foi descrito [Farrag, 1996], um método muito eficiente para encontrar soluções k-tolerante a falhas é através do particionamento em Distancias

m. Sua idéia consiste em particionar o conjunto de offsets em conjuntos disjuntos de elementos,

utili-zando uma seqüência de particionamento que será

gerada da forma descrita a seguir. Após o

particionamento, serão gerados novos Grafos

circulantes, e estes serão transformados em sua con-figuração em bloco, utilizando a técnica demonstra-da adiante, para que os offsets destes grafos em bloco tenham a forma {a', a' + 1,,,.}. Para cada grafo gera-do, deve ser aplicado então a técnica do Teorema 1 para cada grafo em bloco. Isso irá gerar um conjunto de soluções possíveis, isto é, um conjunto de grafos isomórficos. Após gerar esse conjunto de soluções, aquela com o vértice de menor grau em relação ao número de arestas que saem dele será escolhida como a mais eficiente.

Este algoritmo tem a seguinte estrutura básica, que será detalhada mais adiante:

1. Gere um conjunto M de inteiros {ml, ml ,,,.,m). para 1~j~[1-], e tal que todo elemento de M seja relativamente primo a n, isto é, gcd (n, m.) = 1,

para 1 ~ mj~ [1-]; J

2. Para cada mj do conjunto M, encontre a parti-ção correspondente dos offsets usando o pro-cedimento Partição(A, n, m.) descrito adiante,J

e para cada partição construa o grafo

corres-pondente, denotado por Gmj [aI' a2,.",aj: n], onde

i ~ IAI e a.E_, IAI;

3. Para cada grafo Gmj [aI' a2,.",a;: n] gerado no passo (2), construa o grafo em bloco correspon-dente, denotado por BL(Gmj[ai' a2,.",aj:n]),como descrito mais adiante;

4. Para cada BL(G .[amJ I'

a

2,.",a.: n]), use o TeoremaI 1 para construir uma solução k-tolerante a fa-lhas;

S. Compare todas as soluções k-ft construídas em (4) e selecione aquela com o vértice de menor grau.

A seguir, descreveremos mais detalhadamente es-tes cinco passos e o que é necessário para completar o algoritmo.

2.1. Encontrando os elementos do

conjunto M

Nestatécnica,precisamosde um conjuntoM de

númerosm relativamenteprimosa n.

Aqui será usado um procedimento gcd(a, b), que retornao maiordivisorcomum entre dois números ae b. Sabendo que, se gcd (a, b) = 1, então os números

a e b são relativamente primos, podemos gerar todos

os inteiros {ml' ml,,,.,m), tal que para todo mj tenha-mos gcd (n, m) = 1, para 1 ~ mj ~ [1-].

2.2. O particionamento

e a criação dos

grafos

Gmj[aI' a2 a; n]

Esse algoritmo tem por finalidade particionar os

offsets do grafo circulante dado em conjuntos disjuntos. Para isso, usaremos como base os valores de uma seqüência 5 (n, m.), descrita na Definição 4, onde n é o número de véftices do grafo e m. é cadaJ

número inteiro relativamente primo a n gerado con-forme mencionado na seção 2.1 .

O resultado, para cada m. passado para o procedi-mento, será um conjunto d~ subconjuntos disjuntos de offsets.

Para particionar, utilizaremos uma seqüência de particionamento 5, definida da seguinte forma:

Definição 4 Seqüência de particionamento

5eja nem um par de inteiros tal que gcd(x, y)= 1 e n >m >0. Nós definimos uma seqüência ordenada basea-da em m e n, denotabasea-da por 5(n, m) =(51'S2'''''S) onde o

i-ésimo elemento é computado como segue: se [i

>I'

m

(mod n)] ~ [1-], então si = [i >I'm (mod n»), caso contrário, si = n

-

[i>I'm (mod n)], [Farrag, 1996].

Tabela2:SeqüênciaS para n

=

15 e m

=7.

Posi&ãoi

1

2

3

4

5

6

7

si

Artigo 11m!: exatamente [1

deles deveser

todos os númE

Definição 5

distância m

Um subcof! grafo circulan de distância r primo a n, se consecutivost os elementosr junto de distâ está contido distância m. Exemplo 5 qüência 5(1 5, circulante de . os três subcor do conjuntos tância 7. Peladefini(

9 rafo vai perte

ximo de distâl

7

1

6

2

5

3

4

Definição 6

Uma coleçt m definidos so. circulante sen m) será cham cada subconj~ ximo e todo 01

7

14

6

13

5

12

4

1

2

2

2.2.1. SeqüÉ

A partirda

modificações,

.

1. ConstrL segundl 2. Procural junto dI de uma novosu aparece contrad Cada um dE máximo de di Exemplo 6 8, 9, 10, 11, 1 to de offset{1 partição: P(A

11

, 100010),],0101),),01.nOl0), J.00001010UJ.D01.010],000],0010],],00100010],1.010),J.1.D),),),O1.0],1,00001.010U1.DD10101000],00],0),100100010110101.1],0),),),01.0],100. o. D~D],1. Q UOJ.DUDOOOJ.OJ.OU100J,QJ.01.00QJ,OOJ.OUDOJ.OOOJ.OU01.D:l.UDUlO1.0UOOOOJ.OJ.OlUOOJ.OJ.010001.00J.OUOOJ,OQOJ.OUOJ.OUJ.OUJ.OJ.ou,OOOQ1.0J.OU1.001.010),1Rev 1 sta de In f ormát 1 ca Ap 11 cada IUlloJ.ol A no I, n ]

Exemplo 4 5e considerarmos um grafo com n = 15 em = 7, a seqüência 5(n, m) será criada coma

mostra-do na Tabela 2, senmostra-do 5 (15, 7) = (7, 1,6, 2, 5, 3,4).

Lema 1 A seqüência 5 (n, m) contém todos os

ele-mentos de 7 até [1-].

Prova 1 Para qualquer par de inteiros i e j meno-res que n, [i >I'm (mod n)] =

U

>I'm (mod n)]-+ [i>I'm-I >I'

m (mod n)]=

U

>I'm-I >I'm (mod n)], assim, como m-I >I'

m (mod n) = 1 -+i =j. Portanto, todos os elementos de 5 (n, m) devem ser distintos. E como 5 (n, m) contém

~ Artigo

.

Imes

exatamente [~] elementos inteiros positivos, cada um delesdeve ser no máximo igual a[~], além de conter todos os números de 1 até [~].

Definição 5 Subconjunto máximo de

distância m

Um subconjunto de um conjunto de offsets de um grafo circulante de n vértices é chamado subconjunto de distância m, onde m é um inteiro relativamente primo a n, se existe uma subseqüência de elementos consecutivos na seqüência S (n, m) que contém todos

oselementos neste subconjunto. A seguir, um subcon-junto de distância m é chamado máximo se ele não

está contido em nenhum outro subconjunto de

distância m.

Exemplo 5 - Considerando n = 15 e m = 7, a

se-qüência S(15, 7) = (7,1,6,2,5,3,4). Para um grafo circulante de 15 vértices e com os offsets {2, 4, 6, 7}, ostrês subconjuntos {7},{2, 6}e {4}são subconjuntos

do conjuntos dos offsets, todos máximos e com

dis-tância 7.

Pela definição, podemos notar que cada offset do grafovai pertencer a exatamente um subconjunto má-ximode distância m.

Definição 6 Partição em distância m

Uma coleção de subconjuntos disjuntos de distância mdefinidos sobre um conjunto A de offsets de um grafo circulanteserá denotado por P(A, n, m). Então, P(A, n, m)será chamado de Partição de A em distância m se cadasubconjunto de distância m em P(A, n, m) é má-ximo e todo offset em A aparece em P(A, n, m).

2.2.1. Seqüência de construção

A partir daqui, iremos propor algumas pequenas modificações,em relação ao descrito em Farrag, [1996].

1. Construir a seqüência S(n, m) = (s" S2'...,s[j)' segundo a Definição 4.

2. Procuramos cada elemento siem S(n, m) nocon-junto de offsets. Quando o primeiro elemento de uma seqüência for encontrado, iniciamos um novo subconjunto, e quando, em uma seqüência, aparecer o primeiro elemento si que não for en-contrado em A, finalizamos o subconjunto. Cada um desses subconjuntos será um subconjunto máximo de distância m , segundo a Definição 5.

Exemplo 6 Para uma seqüência (1, 2, 3,4,5,6,7,

8,9,10,11,12) deS(25, m) onde m= 1, e

umconjun-to de offset{1, 4, 6, 7, 9, 10, 12} formamos a seguinte partição: P (A, n, m) = {{1}, {4}, {6, 7}, {9, 10}, {12}}.

2.3. Gerando os grafos BL(Gm[al,a2, ..., ai: n])

Baseado nos grafos formados de acordo com o procedimento na seção 2.2, temos então que cons-truir para cada Gmjuma forma de grafo em bloco, de-notado por BL(Gm.[a"a2, ..., aj: n]).

A idéia aqui é transformar os conjuntos particio-nados de distâncias m em seqüências de números

inteiros consecutivos

U,

j + 1, j + 2,...}.

Primeiro, vamos definir o seguinte teorema: Teorema 2 Sejam G e H 2 grafos circulantes de n

vértices com os seguintes conjuntos de offsets

A={al, a2, ..., aj}eB={bl, b2, ..., bJ, respectivamente,

e tal que bi = p

*

aj(mod n), para 1 ~ i ~ j, onde p é

qualquer inteiro que é relativamente primo a n. Então

G e H serão isomórficos.

Prova 2 Sabendo que podemos definir uma função

lp para reordenar os vértices de G, tal que se {x, y}é uma aresta em não direcionada de G, então {lp (x),

lp(y)}

é uma aresta não orientada em H (e portanto

bj

=

(lp (x)

-

lp (y»)(mod n»), sendo então G e H

isomórficos. Podemos então dizer que a função lp (x) = p *x (mod n). Assim, {x, y} =={p *

x (mod n),

p

* y (mod n)}pois (x

-

0(mod n) ==(p *x

- p

*0(mod n)

= p

* (x - 0(mod n) [Knuth, 1973]. Pela Definição 1, ai = (x

-

0(mod n), portanto bi = p *ai'

Desde que n e p sejam relativamente primos, se x

e y forem distintos em G, então lp (x) e lp (0 serão

distintos em H.

Em Farrag, [1996], é descrito como método de ob-ter a forma em bloco de um grafo o processo de mul-tiplicar cada elemento do conjunto de offsets de cada grafo Gm.[a" a2, ..., aj: n] gerado pelo procedimento Partição ~A, n, m.) por m.-I(mod n). Isto está definido) )

a seguir.

Definição 7 Configuração em bloco de um

grafo circulante

Para cada grafo Gm)a" a2, ..., aj: n]gerado confor-me o procediconfor-mento Partição, sua configuração em

blo-co é um novo grafo circulante obtido multiplicando cada elemento do conjunto A de offsets pelo inverso

de mj, denotado por m. -1(mod n). Esse novo grafo será denotado BL(Gm.[a:,a2, ..., aj: n]).

Pela Definição 5, riós podemos ordenar os offsets do conjunto B em alguma ordem tal, que para cada par de offsets inteiros consecutivos x e y nesta or-dem, nós vamos ter, para algum inteiro p qualquer, x= p *m.(mod n) V x= n - p) *m.(mod n), e y= (p + 1))

*m.(moil n) V y= n - (p + 1)*m.(mod n).

Ássim, multiplicando ambos ke ypor m.-I(mod n), iremos produzir o par ordenado (p V - P (/nod n), p + 1 V - P - l(mod n».

Se o primeiro elemento neste par ordenado é - P, ou o segundo é - (p + 1), offset será convertido para a

Iam

!

010001.011.0J.D1UO),},1.0101.1.0000),010),],1001010 ),0001001.0 ),],001.0001.0), 1.01.0).1.1.01],101.01.1.00001.01.0],1.).00101oQ],000],00101],00).0001,0), 1.010}.],1.0U 1.0],Q11.000010101.1J.00J.OJ.01DODJ,OOlOUOO1.DOD1.D1.101.0J.OU1001 .. .

UOJ.OUOQOD1.0J.OU1.DOJ.OJ.01.000J.OOlOUOO1.DOD1.0U0101.UOUJ,01.0UOOOOlOJ.OJ,UDOJ.01.0J.OOO1.00J.OUOOJ.OOO1.0UOJ.01.U01U010UOOOOJ.OJ.DU1.00J.OJ.DlOOOJ.OOJ.OUDDl00010UOOJ.OJ.OOJ.01.0DQD010J.OU),OOJ,O],O I A r t 1 9 o ~gt~1 A r t 1 9 o I~tg~gt

faixa de offset de 1 até

[f],

então o novo par corres-pondente à {x, y} terá sempre a forma (p, p + 1). Isto é aplicável a qualquer par consecutivo no subconjunto ordenado B, isto é, os offsets de B serão convertidos para a forma

V,

j +1, j + 2, ...}.

2.4. Construindo as soluções k-tolerante a falhas para cada BL(Gmj[al. az. ai: n]) Anteriormente, na seção 2.3, geramos os grafos em bloco que consistem de grafos com o conjunto de

offsets consecutivos. é im portante gerar esses grafos

em bloco para termos um melhor resultado do algoritmo definido no Teorema 1, pois esse algo ritmo é ótimo para construção de soluções k-tolerante a falhas onde o grafo possui offsets consecutivos.

Para gerar as extensões k-tolerante a falhas dos grafos BL(G)a" al, ..., ai: n]), conforme descrito em

Farrag, [1996] e em Dutt and Hayes, [1991], nós sim-plesmente adicionamos k vértices a cada grafo

BL(Gm[a"al, ..., ai: n]) utilizando o método do Teorema

1,já que os elementos do conjunto de offsets de cada grafo BL(Gm[a" al, ..., aj"on]) são todos inteiros conse-cutivos.

2.5. Comparação das soluções k-tolerante a falhas de BL(Gm[al. az. ai: n])

É fácil perceber que este procedimento irá gerar diversas soluções. Farrag assumiu como a melhor aquela que gera o conjunto de offsets do grafo circulante H, que é a representação da extensão k-tolerante a falhas de G, com o menor número de ele-mentos. Isso porque o grau de qualquer vértice v pertencente ao conjunto V' é calculado como sendo o número de elementos no conjunto de offsets de H vezes dois, isto é, IHI * 2. Este calculo é feito assim devido à alta simetria do grafo circulante.

Neste ponto, devemos então comparar os conjun-tos de offsets de todos os grafos BL(Gm)a" al, ..., ai:

n])gerados na

seção

2.4, eliminar os offsets repeti-dos de cada conjunto de offsets, e escolher o conjun-to com menor número de elemenconjun-tos.

3. O ALGORITMO COMO UM

PSEUDOCÓDIGO

Nestaseção,iremos descreverdetalhadamenteo algoritmo, fornecendo seu pseudocódigo e explican-do como ele funciona.

3.1.

Encontrando a melhor solução

k-tolerante a falhas

Conforme apresentado em Farrag, [1996], pode-mos escrever o pseudocódigo do algoritmo, de uma forma mais geral, como apresentado no Algoritmo 1.

Sua função é, após encontrar várias soluções k-tole-rante a falhas possíveis, selecionar a melhor, confor-me descrito na seção 2

Para todas as listas usadas, convencionamos usar uma estrutura de dados que contém um número in-teiro que indica o tamanho da lista, e uma lista encadeada de números inteiros, na qual a inserção será sempre no começo da lista. Para simplificação do pseudocódigo, convencionamos acessá-Ia da mes-ma formes-ma que um vetor estático. Mas no caso de in-serção de novos elementos, estamos assumindo que esse vetor crescerá dinamicamente em uma posição. Assim, para o procedimento Tamanho (Lista), a or-dem de complexidade é 0(1), pois ele apenas deve ler e retornar o número inteiro dessa estrutura que representa o tamanho da lista. Para inserção, mesmo sendo necessário alocar espaço para mais um elemen-to e incrementar o valor desse número inteiro em 1, como a inserção será sempre no começo da lista, sua complexidade será também O (l), porém, a busca terá complexidade O(n).

Para o Algoritmo 1 são passados dois parâmetros: o primeiro é o grafo circulante G, na forma de uma estrutura de dados contendo o número de vértices do grafo circulante original e uma sub-estrutura que contém uma lista dos offsets {ai' al, ..., a n/2}. O se-gundo parâmetro é o número k, que indica o número de vértices falhos a serem tolerados.

1: KFT(G,k)

2: Lista de_Primos <- ListaRPrimos(G.n) 3: TamanhoLista <- Tamanho(Lista de Primos) 4: L <- 1

5: para i <- 1 até TamanhoLista faça

6: ListaParticoes <- Particao(G,Lista de Primos[i]) 7: paraJ <- 1 ate Tamanho(ListaParticoes) faça 8: GrafoBloco <- GeraGrafoBloco(ListaParticoesU)) 9: KFT<- GeraKFT(GrafoBloco[i],k) 10: ListaKFT[L]<- KFT 11: L<-L+l 12: fim para 13: fim para 14: OtimoKFT <- BuscaOtimoKFT(ListaKFT) 15: Retome OtimoKFT

Algoritmo 1: Encontra a solução k-tolerante a falhas do grafo G.

Após analisarmos a complexidade de cada passo intermediário do Algoritmo 1, retomaremos à análise de sua complexidade.

3.2. Os passos intermediários

Aqui, iremos descrever cada

passo intermediário

do algoritmo e suas funcionalidades.

11

.

lOOD10l1.01.0UJ.O],],1.010UDDD01.01.01,1.l,OOJ.OJ.01.D0010D1.0UOD1.0DOJ.O),1.01.0U1.D],),1.DJ.OUOOOOJ.Ol01UOO1.0l0J.OOOJ.oOJ,oUOO1.0001.01.J.01.01.U01.1.1.01.O),),O. ..

uOJ,ouaoooJ.O),OJ.UOD],01.0],OOO),OOlOUD01.00010UOJ.01UDU1.01.DUODD01.0J,I]].UOQJ.01,01.0001.DO],OUOOJ.OOOJ.OU010J.UOUJ,OlOUOODOJ.OJ.O1o),],0010J.01.1R ev 1 sta de In f armá t1 ca Ap 11 cada

3.2.1. Encor relati O Algoritm números mi ri que, no nosso G fornecido. Éfácil percE buição de valol inserção de rp a complexidad 1: ListaRPrim< 2: J <- 1 3: para i <- 2 4: rp <- Eu 5: se rp = 6: LU]+ 7: J <- J 8: fim se 9: fim para 1O: RetomaL Algoritmo 2: Ca pr

o

cálculo execução do) to, chamadoE comum" entn máximo divise à 1, então es! Esse procedin complexidadl 1973]. Apena Euclides é exi 1:Euclides(a, 2: se b=Oen 3: retoma 4: senão 5: Euclide: 6: fim se Algoritmo 3: VE pr 3.2.2. Parti~ Nessealg( G original é SI como base a! 5, que será e) recebe como números miI Calculanc be como ent vértices do 9 mente primo

luções k-tole- elhor,confor-ionamosusar m número in-e uma lista lalainserção simplificação ;sá-Iada mes-10caso de in-.sumindo

que

uma

posição. I(Lista),a or-apenas deve ~strutura que !rção,mesmo is um elemen-inteiro em 1 , a da lista, sua

I,a busca terá 5parâmetros: arma de uma '0 de vértices estrutura que ,a n/2}. O se-lica o número 5) Imo5[i)) ) faça Particoes U)) ~has do grafo G. ~ecada passo Imosà análise lintermed iário

I

I

imes

Ar t i 9 o 1~~g~g~~~~g~~Mà~tUgtgt~~gggtgà~àHggtgàgtg~~à~gt~tà~~tg~gt~ààgà~Mà~nàgtgtà~gggtgà~àttggtgàgtg~~à~gt~tà~~tg~gt~ààgà~Mà~ttàgtgtà~gggtgà~àttggtgàgtg~~àg~à~àà~gtgggà~universidade

3.2.1. Encontrando a lista de números m

relativamente

primos à n

OAlgoritmo2 é usado

para encontrar uma lista de

números mi relativamente primos a um número n , que, no nosso caso, é o número de vértices do grafo Gfornecido.

Éfácil perceber que, no pior dos casos, tanto a atri-buiçãode valores a rpquanto a comparação e posterior inserçãode rp àlistaL irá ocorrer [-g-]vezes. Portanto,

acomplexidade do Algoritmo 2 é de O (n log2n).

1: ListaRPrimos(n) 2: J

-

1

3: para i

-

2 até [-g-]faça 4: rp

-

Euclides(n,i) 5: se rp = 1 então 6: LU]

-

rp 7: j -j+1 8: fim se 9: fim para 10: Retorna L

Algoritmo 2: Calcula uma lista de números m relativamente primos a n.

o cálculo do máximo divisor comum

-

Para a

execução do Algoritmo 2, é utilizado um procedimen-to,chamado Euclides(n,i)que calcula o "máximo divisor comum" entre dois números inteiros a e b. Caso o máximo divisor comum entre esses números seja igual à 1, então esses números são relativamente primos. Esseprocedimento utiliza o algo ritmo de Euclides, de

complexidade O (log2 n), demonstrado em [Knuth,

1973]. Apenas para fins ilustrativos, o algoritmo de Euclides é exibido no Algoritmo 3

1: Euclides(a,b) 2: se b=Oentão 3: retornaa 4: senão 5: Euclides (b, mod(a,b) 6: fim se

Algoritmo 3: Verifica sedoisnúmeros a e b sãorelativamente primos.

3.2.2. Particionando O conjunto dos offsets

Nesse algo ritmo, o conjunto dos offsets do grafo Goriginal é separado em partições disjuntas, usando como base a seqüência 5, gerada através do Algoritmo 5, que será explicado a seguir. Para sua execução, ele recebe como parâmetros o grafo g original e um dos números mi do conjunto M.

Calculando a seqüencia S

-

O Algoritmo 5

rece-be como entrada o número n , que é o número de vértices do grafo G, e m, um número inteiro relativa-mente primo a n, gerado pelo Algoritmo 2, estando

no intervalo de 1 até [-g-]. O resultado desse algoritmo

é uma seqüência ordenada segundo a Definição 4.

Complexidade do Algoritmo 5

-

Na linha 3 do

Algoritmo 5 tanto a multiplicação i>I'

m quanto o

cálcu-lo do moducálcu-lo mod(i >I'm, n) tem complexidade 0(1). A comparação da linha 4 também tem complexidade

0(1). Sabendo que a inserção do elemento S à lista

S [i]é de complexidade 0(1), e sabendo que os pas-sos das linhas 3 até 7 irão executar [-g-]vezes,conclu-ímos que a complexidade do Algoritmo 5 é O (n).

1: Particao(G,m)

2: SequenciaS

-

GeraSeqS(G.n,m) 3: parai <- 1 ate[-g-]faça

4: j <- 1

5: Resp <- Busca(SequenciaS[i], G.A) 6: se Resp= 1 então 7: ListaParticoesU] <- SequenciaS[i] 8: J <- J + 1 9: fim se 10: fim para 11: Retorne Listaparticoes

Algoritmo 4: Gera um particionamento dos oftsets do grafo

G, em partições máximas de distância m. 1: GeraSeqS(n,m)

2: para i <- 1 ate[-g-]faça 3: 5 <- mod(i*m,n) 4: se 5 > [-g-]então 5: 5

-

n

-

5 6: fim se 7: S[i] <- 5 8: fim para 9: Retorna S

Algoritmo 5: Gera uma seqüência de números de 1 até

[1],

ordenados segundo a Definição4.

Podemos perceber que a operação elementar do Algoritmo 4 é a busca seqüencial executada na linha 5, que irá pesquisar se o elemento SequenciaS[i] exis-te na lista conexis-tendo o conjunto A dos offsets. Saben-do que o tempo de busca seqüencial de um elemento em uma lista não ordenada é de ordem O (n), e que no nosso caso n = IAI,temos então um tempo de bus-ca de ordem O (IA!).

Como o esta busca será executada dentro de um

laço que irá repetir [-g-],a complexidade do Algoritmo

4 é O (nIAI).

3.2.3. Encontrando

sua forma em bloco

O Algoritmo6 é usado para encontrar a forma em

bloco do grafo (G)a" az, ..., aj:n]),isto é, encontrar o

Grafo BL (Gm[al' az, ..., aj: n]).

Para sua execução, são passados como parâmetros uma lista de partições geradas pelo Algoritmo 4, e os

números nem, relativamente primos.

11

,~ Q.. 010000101101.0U10U 1.0100),JoOODO100),0),),),00 1.01.01.000 :1.00:1.0),),001.000),0),),0101,), ),ou 10 100U000010101.), 1.001010 1.000100100:u.OO),OOO),O101.0100U101UO 1.01.10010),],000],

II An o I I n 1, J a n / J Un 2 OO5 IU01.ouoooOJ.OJ,OJ,UOO1.D1.01.0001.DOJ.OUODJ,DOOJ.OJ,101.D11.101UOJ,OUOO00I010UJ.OOJ.01.0J.0001001.0UDOl,D0010U01.0UJ.OJ.U01.DUD00010lOU1.00J.OJ.OUOJ.o01.oua

U

.

OJ.OOOJ.D1.1.D1.D1.1.1.DJ,1.1.D1.0],],OOOD1.D1.D),),1.DOJ.Q1.0J.OOOJ,OD1.01.1oDOJ.0001.0],),01.01.),1.01.],1.0],010100000101.0],1,1.001.01.01.00010010],],001.000lO),),01.0),),J,DJ.UOJ.Ol1.00D0101.0),),],OOlOJ,D1.0D01.001.0U001000101101010),1.1001

.

1 Ar t1.₉O mult8t51_{Ar t 19}0 Ing! ),),01.(I1.1.000010101.1100101o01.000J,001.0UOO:l.OOO1.0),1.01.0),),),0),),),OlD1J.IJlJOOJ.01D11),DOJ.OJ.OJ.oOO),OOJ,011D01DOOJ.O),),OlOlllOlJ,J,OJ.01J.D00010101U001010).DOD1DOJ.O],],001DOD10U001DJ.OOlIJ),OQOQOlDJ.O),UOD101D b,üI=' 1: GeraGrafoBloco(ListaParticoes,m,n) 2: i - 11m 3: t~manho- Tamanho(ListaParticoes)

4: para i

-

1 ate tamanho faça 5: offset - im* ListaParticoes(i]

6: se Nao_lnteiro(offset) então 7: offset -n - ListaParticoes[i] 8: offset -offset * im 9: se Se Nao_lnteiro(offset) então 10: offset -n +ListaParticoes(i] 11: offset -offset * im 12: fim se 13: fim se 14: Grafo.offset[i] -offset 15: fim para 16: Retome Grafo

Algoritmo 6: A partir de uma lista de números pertencentes a uma partição P (A, n, m), do número m. e do tamanho do grafo G original, encontra súa forma em bloco.

Como é possível ver, o passo principal do Algoritmo 6 é o laço para da linha 4. Como a complexidade de todos os outros passos internos a esse laço é igual a O (l), e esse laço irá executar IAIvezes (devido ao tamanho máximo de ListaParticoes ser IAI),então a complexidade desse algoritmo é O (lAI).

3.2.4. Encontrando a solução k-tolerante a

falhas de cada BL(Gm[al, a2,..., a[j]]

Após particionar o conjunto de offsets em conjuntos disjuntos e encontrar sua forma em bloco, esse algo-ritmo usa a técnica do Teorema 1 para gerar a solução k-tolerante a falhas do Grafo BL (G)a" az' ..., ai: n].

1: GeraKFT(Grafo, k) 2: A

-

C.A

3: tamanho

-

Tamanho(A)

4: para i

-

1 até tamanho faça

5: Hash_lnsere(hash_solucao,n,A[i])

6: para L

-

1 até k faça

7: Hash_lnsere(hash_solucao,n,A[i] + L) 8: fim para

9: fim para

10: retome hash_solucao

Algoritmo 7: Gera a solução k-tolerante a falhas para um dado grafo G e para um dado número k de vértices falhos a serem tolerados.

Na linha 5 do Algoritmo 7, utilizamos um procedi-mento chamado Hash_lnsere. Esseprocediprocedi-mento uti-liza uma função Hash para calcular a posição onde deverá ser inserido o offsetencontrado. Utilizaremos apenas um vetor estático, sem utilizar a técnica co-nhecida como chaining para resolver a colisão. Isso porque devemos armazenar apenas uma vez o núme-ro encontrado, utilizando, então, uma função Hash apenas porque a complexidade de inserção será de ordem O (1). Assim, como esse procedimento Hash_lnsere é executado dentro do laço para da

li-nha 6, que será executado kvezes, sendo k o número de tolerância a falhas desejadas, e esse laço para da linha 6 será executado IAIvezes, então a complexida-de complexida-desse algoritmo é complexida-de O (IAlk).

3.3. A complexidade final

Agora, quejá temos a complexidade de cada pas-so do Algoritmo 1, podemos ver qual será a comple-xidade do Algoritmo como um todo.

Como vimos acima, o

passo

da linha 2 (a execução do Algoritmo 2), tem complexidade O (n log2n).Já a execução do procedimento Tamanho(Lista_de_Primos) na linha 3 tem complexidade 0(1), como dito no ini-cio daseção 3.1 . Como resultado, este procedimento retoma a quantidade de números m; relativamente primos ao tamanho do grafo G original, que será no máximo igual a n.

Por isso, o laço para da linha 5 será executado no máximo

[fI

vezes. Na linha 6, a execução do procedi-mento Partição é da ordem O (nlAI), como demonstra-do na seção 3.2.2.

A seguir, na linha 7 é executado o procedimento GeraGrafoBloco e na linha 8 o algoritmo GeraKFT, de complexidades O (IAI)e O (IAlk),respectivamente.

Assim, o conteúdo interno do laço da linha 5 tem complexidade O{nlAI + IAlk). Como

esse

laço será exe-cutado n vezes, a complexidade final do Algoritmo 1 é de ordem O(n2IAI + n k IAI).

4. CONCLUSÃO

Este estudo do trabalho publicado em Farrag, [1996] foi muito útil para pôr em prática as teorias apresentadas por Farrag. Atingimos com sucesso a expectativa de explicar e implementar a técnica de particionamento em distancias m para projeto de ex-tensões k-tolerante a falhas proposta.

Apesar de ser um método relativamente simples de implementar, sua conceituação teórica é compli-cada, envolvendo um razoável nível de abstração matemática.

Foi possível na implementação perceber pequenos detalhes que facilitam a compreensão do procedimen-to como um procedimen-todo, como a idéia de gerar a partição P

(A, n, m), para, em seguida, encontrar a forma em

bloco deste grafo.

Podemos, então, sugerir como uma continuação do trabalho uma pesquisa mais aprofundada em um método que permitisse prever quais seriam os grafos que iriam gerar as melhores soluções. Aparentemen-te, são os grafos em bloco com o menor número de subconjuntos, porém não foi possível a comprovação desta hipótese.

Sefor possível prever quais os grafos que geram as melhores soluções, seria útil, então, sugerir a utilização de um algoritmo como o Union/Find, por exemplo, para armazenar os subconjuntos de offsets da partição

BL

(P(A, n, m)),

pois a inserção de novos offsets pode-ria gerar a união de dois subconjuntos.

11

: 10001.0),1,01.0],], lD1U,O lU}'10000 lU lU]' l 1.001010 lD00100 10 uoo lODO10llOlD1.1.10111.010 U000010 lU]' l ),00],0 10 ],000 1.001.0),1.00),0001.0), 1.0),0),UO l)' 10 1.0l],O' o.

1101.01100001.01.01011.001.01.01000100101100100010),),0),0111.01.11.010:1.),0000101.01.11001.01.010001.001.0],1.001.0001.0),),01.0],1.],01.110lD11DDOOlOlOlU00101011 Rev 1 sta de In f ormát 1 ca Ap 11 cada

r--!

-BANATRE,J. P. ! tQlerant multil

I

Workstation ( i Workshop on · September 27. Street, ter Soc DUTT, S. Oesic 1::--_;..__....__-._-.---....---___..--__-.. multlprocesso r Universíty of ~ I DUTT, S.; HAY · automorphism

.

Computing, 1 FAR~G. A. AI, of the circulan Fifth Symposi Computation, · Press. Oalhou!

Ano1, nQ

)ko número laçopara da complexida- decadapas-ráa comple-(aexecução ?{092n).Já a Lde_Primos) ) dito no ini-'ocedimento !Iativamente queserá no )(ecutadono I doprocedi-I demonstra-'ocedimento GeraKFT,de vamente. Ilinha 5 tem iÇOseráexe-Algoritmo 1 em Farrag, :a as teorias m sucessoa a técnica de rojetode ex-~ntesimples ca é compli-le abstração lerpequenos

procedimen-.

a partição P a forma em continuação dadaem um amosgrafos parentemen-Ir númerode 10mprovação uegeramas irautilização emplo,para da partição

{fsetspode-~--

--

--,.. _:.--nnn 't~~ *~\'"'-

,.\__(REFE:R~NCIAS

~",'_,''''.'C'''.'.'.'.'_'.';';'.';==".w'''~À'~'',';';

BIBLIOGRÁFICAS

;.;.;;.__; ;, "._~ ..._...

~,,"__'),E"',,"._

, G~Architecture of faúlt--, '.,. ,""-'- -.- .__'o ."..

.ns:in IEEE:editor,

of the Secorid

__m_ (WWOS-II),

s 20;'24, 1109

20910, USA. IEEE

DU1:T;S. Desig~JM and reco mul!jpr,

Unive

ult-tolerant . irt CSE-TR-73-90, O.

FARRAG,A. A. tJewiillgorithm for c6~structing fault-tolerant ,so!üti.ons ofthe., circulant graphconfiguration. Parallel

COJnputJng,22(9):t239-1253 (or 1239-125417),1996.

The Art óf\éolT!P SelT!.inum.ericalAIgorithms. A second editio(l, 1973.

'Programming, Vol. 2: n-Wesley, Reading, MA,

rnslising ed

Ring-connected networks and their ected cyeles and dynamic redúndancy:r:tetworks. 'IEEE"Transactions on.parallel and iDistributed Systems, 6(9):988-996, 1995.

WEISSTEíN,"E; Eric We,isstein's world of'mathematics. hnp:// mathworld.wol(ram.com, 2000.

wu. J. Afault-tolerant ad~ptive and minlO1alrouting scheme in n-D meshes. Jn Proceedi~gs of;2ooo International Conference on Parallerflr:ocessiJ'!g(29tbICPP'OO), Toronto, Canada. Ohio State Ul)iy,2000.

D

.

Q .. 01.D00101o:l.010],],),011).01.01.).00001010),],1001010100010010U001000101.),01.011101.U01011.0000101.01.),),00101.01D0010010),),0010001.0),),01OU10J.U010UDOJ.D11DOOl

Ano II n 1, Ja n/ JUn 2 [][]5 IU01D:u,OOOD101.0U1001D1D1D0010DJ,OU.OOJ.OOD10UOJ.OU,lDU1010UDOOD1DJ.01U001010J,DOD1,0010UODJ.OOOJ.OUD:l.OJ,uOJ.uOJ.OUOOODJ.D10UJ.00101.0U010010],],0

ing fault-tolerant solutions roceedings of the

. Parallel

itos, California.IEEECompl.iter Society ity, 1995.