SIMULAÇÃO DE ALGORITMOS DE ROTEAMENTO UNICAST … · algoritmos de roteamento, as propriedades...

FACULDADE FARIAS BRITO CIÊNCIA DA COMPUTAÇÃO

SAMUEL ALVES SOARES

SIMULAÇÃO DE ALGORITMOS DE ROTEAMENTO UNICAST UTILIZANDO O SIMULADOR NS-2

Fortaleza – 2009

1

SAMUEL ALVES SOARES


Monografia apresentada para obtenção dos créditos da disciplina Trabalho de Conclusão do Curso da Faculdade Farias Brito, como parte das exigências para graduação no Curso de Ciência da Computação. Orientador: Prof. Maikol Magalhães Rodrigues, M. Sc.

Fortaleza – 2009

2


Samuel Alves Soares

NOTA: FINAL (0 – 10): _______ Data: ____/____/_________ BANCA EXAMINADORA:

___________________________________ Prof. Maikol Magalhães Rodrigues, M. Sc

(Orientador)

___________________________________ Prof. Roberto de Almeida Façanha, M. Sc

(Examinador)

__________________________________ Prof. Sérgio Araújo Yunes, M. Sc

(Examinador)

3

“Ó profundidade das riquezas,

tanto da sabedoria, como da ciência de Deus!

Quão insondáveis são os seus juízos,

e quão inescrutáveis, os seus caminhos!”

Romanos 11.33

4

DEDICATÓRIA

Aos meus pais e irmãos. Vocês são presentes de Deus para mim. Eu não teria

chegado até aqui sem o amor de vocês.

À minha esposa, Yally. Minha companheira de todos os momentos, você é o

motivo que me faz seguir em frente.

5

RESUMO

Existem muitos algoritmos de roteamento utilizados em redes de computadores

com idéias e objetivos distintos, os quais procuram solucionar vários problemas no

roteamento de pacotes. Este trabalho apresenta vários algoritmos utilizados em redes de

computadores unicast e simulações dos algoritmos que são predominantes nesse tipo de rede.

As simulações são realizadas com o conceituado simulador ns-2 e apresenta particularidades

que acontecem na execução dos algoritmos e suas reações com a mudança no custo dos

enlaces. Essas simulações mostram a grande diferença de desempenho que existe entre

algoritmos estáticos e dinâmicos. Também é apresentado um algoritmo que estende a idéia do

algoritmo de Dijkstra e procura balancear a carga na rede em topologias que formam anéis.

6

SUMÁRIO

INTRODUÇÃO........................................................................................................................13

1 REVISÃO BIBLIOGRÁFICA..............................................................................................15

1.1 Roteamento em Redes de Computadores ......................................................................15

1.1.1 Métricas utilizadas no roteamento .........................................................................16

1.1.2 Roteamento Unicast ...............................................................................................16

1.2 Grafos.............................................................................................................................17

1.2.1 Cadeia e Caminho ..................................................................................................18

1.2.2 Grafos ponderados .................................................................................................18

1.2.3 Grafos orientados e não orientados ........................................................................19

1.2.4 Grafos conectados e não conectados......................................................................19

1.2.5 Matriz de Adjacências e Lista de Adjacências.......................................................19

1.3 Algoritmos de Roteamento ............................................................................................20

1.3.1 Roteamento pelo caminho mais curto ....................................................................21

1.3.2 Roteamento por Inundação ....................................................................................21

1.3.3 Algoritmos de vetor de distância............................................................................22

1.3.4 Algoritmos de Estado de Enlace ............................................................................22

1.3.5 Roteamento Ótimo .................................................................................................23

1.3.6 Algoritmos com Parâmetros de Qualidade de Serviço (QoS)................................24

1.3.7 Algoritmos para Redes Móveis Ad-hoc .................................................................24

1.4 Classificação dos algoritmos de roteamento..................................................................26

1.4.1 Estático ou Dinâmico .............................................................................................26

1.4.2 Global ou Descentralizado .....................................................................................27

1.4.3 Sensíveis à carga ou insensíveis à carga ................................................................27

1.4.4 Caminhos mínimos e caminhos múltiplos .............................................................27

7

1.4.5 Planos ou hierárquicos ...........................................................................................28

1.5 Propriedades dos Algoritmos de Roteamento................................................................28

2 ALGORITMOS DE ROTEAMENTO UNICAST.................................................................29

2.1 O Algoritmo de Dijkstra ................................................................................................30

2.2 Algoritmo Estendido de Dijkstra ...................................................................................33

2.3 Algoritmo de Floyd-Warshall........................................................................................36

2.4 Algoritmo de Roteamento por Vetor de Distância ........................................................36

2.5 Algoritmo de Roteamento por Estado de Enlace...........................................................39

3 SIMULAÇÃO .......................................................................................................................42

3.1 O Simulador Network Simulator-2 ................................................................................42

3.2 Topologia e Ambiente de Simulação.............................................................................47

4 SIMULAÇÃO DOS ALGORITMOS DE ROTEAMENTO ................................................50

4.1 Simulações e Resultados................................................................................................51

4.2 Análise dos Resultados Computacionais .......................................................................61

5 CONCLUSÃO.......................................................................................................................63

5.1 Contribuições e Trabalhos Futuros ................................................................................64

APÊNDICE ..............................................................................................................................65

REFERÊNCIAS BIBLIOGRÁFICAS .....................................................................................74

8

LISTA DE FIGURAS

Figura 1: Representação de uma rede através de grafo. ...........................................................18

Figura 2: Grafo orientado. ........................................................................................................19

Figura 3: Matriz de adjacências................................................................................................20

Figura 4: Lista de adjacências. .................................................................................................20

Figura 5: Evolução do desenvolvimento dos algoritmos de roteamento..................................24

Figura 6: Alguns algoritmos MANETs. ...................................................................................26

Figura 7: Pseudocódigo do algoritmo de Dijkstra. ...................................................................31

Figura 8: Rede com seis roteadores modelada como um grafo. O nó a é a origem. ................31

Figura 9: Execução do algoritmo de Dijkstra com origem no nó a. ........................................33

Figura 10: Parte da Rede Óptica Européia. Várias sub-redes em anéis podem ser formadas

com esses nós. Fonte: GARCIA et. al., 2007...........................................................................34

Figura 11: Trecho incluído no algoritmo de Dijkstra para melhorar o balanceamento e

simetria no roteamento em topologias de rede em anel. ..........................................................35

Figura 12: Figuras (a) e (b) mostram as rotas na execução de duas implementações distintas

do algoritmo de Dijkstra. A figura (c) ilustra a execução do algoritmo Estendido de Dijkstra.

..................................................................................................................................................35

Figura 13: Pseudocódigo do algoritmo de Floyd-Warshall. ....................................................36

Figura 14: Algoritmo de vetor de distância. .............................................................................38

Figura 15: Alteração no custo do enlace (x, y) provocando problema de contagem ao infinito.

..................................................................................................................................................38

Figura 16: Oscilações que podem ocorrer com o roteamento por estado de enlace quando se

usam métricas baseada no congestionamento ou no atraso. Fonte: KUROSE e ROSS, 2006, p.

280. ...........................................................................................................................................40

Figura 17: Exemplo de script de simulação. ............................................................................44

9

Figura 18: Execução do cenário apresentado: três nós com um fluxo saindo do nó 0 ao nó 2.45

Figura 19: Algumas linhas do trace gerado pelo ns-2..............................................................46

Figura 20: Rede Abilene, parte do projeto da Internet 2...........................................................48

Figura 21: Primeira rede usada na simulação gerada pelo nam ...............................................48

Figura 22: Segunda rede usada na simulação gerada com o nam ............................................49

Figura 23: Informação de utilização de Vetor de Distância no roteamento de pacotes na

simulação da rede. ....................................................................................................................50

Figura 24: Simulação com o algoritmo de Dijkstra com perda de três enlaces na rede de

topologia baseada na rede Abilene. ..........................................................................................53

Figura 25: Simulação do algoritmo de Estado de Enlace com perda de três enlaces na rede. .55

Figura 26: Simulação com o algoritmo de Vetor de Distância com perda de três enlaces na

rede. ..........................................................................................................................................57

10

LISTA DE TABELAS

Tabela 1: Eventos que podem aparecer num arquivo trace .tr.................................................46

Tabela 2: Configurações do computador onde foram feitas as simulações..............................50

Tabela 3: Resultados da simulação dos algoritmos de roteamento sobre a rede da figura 21 .52

Tabela 4: Resultados da simulação dos algoritmos de roteamento sobre a rede da figura 21

onde três enlaces ficam indisponíveis ......................................................................................52

Tabela 5: Resultado da simulação sobre a rede da figura 22, sem alteração nos enlaces ........59

Tabela 6: Resultado da segunda simulação, onde o enlace (3, 4) fica indisponível.................59

Tabela 7: Resultado de simulação sobre a rede da figura 22 com 6 tráfegos...........................59

Tabela 8: Resultado da simulação sobre a rede 1 com oscilação no roteamento. ....................60

Tabela 9: Resultado da simulação com a perda dos enlaces (10, 9) e (1, 2) na rede 1 para

verificação de formação de loops e contagem ao infinito. .......................................................61

11

LISTA DE ABREVIATURAS E SIGLAS

NS-2 Network Simulator-2

TTL Time to Live

RIP Routing Information Protocol

IGRP Interior Gateway Routing Protocol

OSPF Open Shortest Path First

IS-IS Intermediate System-Intermediate System

WSP Widest Shortest Path

SWP Shortest Widest Path

MRBHP Maximum Ratio of Bandwidth and Hop Path

QoS Quality of Service

MANET Mobile Ad-hoc Networks

DSR Dynamic Source Routing

AODV Ad-hoc On-Demand Distance Vector

GSR Global State Routing

TORA Temporally-Ordered Routing Algorithm

OLSR Optimized Link State Routing

ZRP Zone Routing Protocol

LAR Location-Aided Routing

EON European Optical Network

VINT Virtual InterNetwork Testbed

LBNL Lawrence Berkeley National Laboratory

USC/ISI University of Southern California/Information Sciences Institute

NAM Network Animator

UDP User Datagram Protocol

12

CBR Constant Bit Rate

IPv6 Internet Protocol versão 6

TCP Transmission Control Protocol

FTP File Transfer Protocol

13

INTRODUÇÃO

As redes de computadores têm se tornado fundamentais na sociedade atual, sendo

usadas por diversas organizações do mundo (TANEMBAUM, 2003) e para os mais diversos

fins como, por exemplo, compartilhamento de arquivos, comunicação, teleconferência,

comércio e educação (KUROSE e ROSS, 2006). Esse crescimento, principalmente com a

popularização da Internet, tornou-as bastante complexas, exigindo protocolos de comunicação

e de transportes muito sofisticados (KUROSE e ROSS, 2006).

Um dos trabalhos cruciais da rede, devido ao grande tráfego de dados, está no

roteamento de pacotes, ou seja, o envio de pacotes de um sistema final a outro. Esse trabalho

exige um bom algoritmo não só para calcular a melhor rota, mas também para lidar com

fatores como congestionamento em redes e informações sensíveis ao tempo (LIU, LOU e

FANG, 2003; KUROSE e ROSS, 2006).

Muitos algoritmos para o roteamento de pacotes em redes de datagramas surgiram

ao longo do tempo, cada um buscando atender a uma necessidade especial ou melhorando

algum algoritmo já desenvolvido (KUROSE e ROSS, 2006; SEGUÍ et. al., 2006). Redes de

datagramas não estabelecem uma conexão entre os sistemas finais como acontece com redes

de circuitos virtuais. Os pacotes podem ser distribuídos por diferentes caminhos, dependendo

do algoritmo de roteamento empregado (KUROSE e ROSS, 2006).

Devido à necessidade de parâmetros de qualidade de serviço, muitos trabalhos de

pesquisa atuais estão voltados para a implementação de protocolos que atendem a esses

parâmetros. Também há muitos trabalhos recentes sobre o roteamento em redes móveis ad-

hoc.

14

Neste trabalho serão apresentadas discussões e feitas simulações de algoritmos de

roteamento desenvolvidos para redes de datagramas, mais especificamente algoritmos

utilizados em redes de computadores de comunicação unicast, nos quais a comunicação é

feita de um sistema final a outro sistema final (TANEMBAUM, 2003; SEGUÍ et. al., 2006).

Serão estudados algoritmos de roteamento unicast em redes não móveis, sem levar em conta

parâmetros de qualidade de serviço. Esses algoritmos utilizam apenas uma métrica para o

cálculo do caminho de menor custo.

Inicialmente serão expostos alguns conceitos que envolvem o roteamento e, dada

a importância da teoria dos grafos para a modelagem de redes de computadores, serão

explanados vários conceitos úteis sobre grafos. Serão abordadas as classificações dos

algoritmos de roteamento, as propriedades que são esperadas deles e os algoritmos a serem

analisados neste trabalho, bem como uma explanação sobre outros grupos de algoritmos de

roteamento e protocolos que os utilizam.

A seguir são detalhados os algoritmos utilizados no roteamento de pacotes em

redes de computadores unicast. Serão discutidas suas complexidades algorítmicas e

características especiais de cada algoritmo. Suas implementações serão descritas através de

pseudocódigo.

Para exemplificação da execução dos algoritmos, será utilizado um simulador de

rede, o Network Simulator-2 (ns-2) (FALL e VARADHAN, 2009). No capítulo 3 serão

explanadas suas principais características e como ele é utilizado para simulação do

roteamento. Nesse mesmo capítulo, será apresentado o ambiente de rede em que será

realizada a simulação. Após isso, no capítulo 4, serão apresentadas as simulações realizadas

com os algoritmos escolhidos e uma discussão dos resultados obtidos através da simulação,

seguida da conclusão sobre o que foi discutido neste trabalho.

Estudar e comparar esses algoritmos ajudará na escolha daqueles que são mais

adequados para cada necessidade enfrentada, reduzir custos e tempo de espera e poderá abrir

caminho para o desenvolvimento de novos algoritmos mais eficientes e eficazes

(TANEMBAUM, 2003; KUROSE e ROSS, 2006). Além disso, esse estudo e simulação

fornecem uma boa compreensão de como é projetado o roteamento em diversos tipos de

redes.

15

1 REVISÃO BIBLIOGRÁFICA

Neste capítulo é dado o embasamento teórico para o entendimento deste trabalho.

Será fornecida uma visão geral sobre o roteamento em redes de computadores, os principais

conceitos sobre grafos, que são utilizados para modelagem de redes, e algoritmos de

roteamento usados nas redes em geral.

1.1 Roteamento em Redes de Computadores

A camada de rede é a terceira camada na pilha de protocolos de uma rede de

computadores (KUROSE e ROSS, 2006). Ela é composta por roteadores e enlaces que os

conectam. Quando um pacote é enviado de um sistema a outro, o pacote percorre uma série de

roteadores e enlaces. Ao chegar numa porta de entrada do roteador, o pacote é repassado para

a porta de saída apropriada a fim de que possa chegar ao destino correto, de acordo com a

tabela de repasse que é atualizada pelo algoritmo de roteamento. Este é executado sobre o

roteador ou conjunto de roteadores (TANEMBAUM, 2003; KUROSE e ROSS, 2006).

O ato de levar um pacote da porta de entrada de um roteador para a sua porta de

saída é chamado de repasse (KUROSE e ROSS, 2006). Geralmente vários pacotes chegam a

um mesmo roteador e muitos caminhos possíveis da origem ao destino podem estar

congestionados (TANEMBAUM, 2003; KUROSE e ROSS, 2006). Vários algoritmos

verificam esses fatos e procuram elaborar o melhor plano para a entrega do pacote (LORENZ

et. al., 2006).

O roteamento consiste na escolha de um caminho fim-a-fim que os pacotes devem

percorrer para alcançar o destino. Este caminho fim-a-fim pode ser encontrado de diversas

16

formas, dependendo de qual algoritmo de roteamento está sendo utilizado e da forma de

comunicação que se pretende realizar o roteamento (KUROSE e ROSS, 2006).

1.1.1 Métricas utilizadas no roteamento

Um algoritmo de roteamento utiliza uma ou mais métricas para seleção do

caminho entre dois nós. Essas métricas também podem ser denominadas de funções de custo

de uma aresta (KUROSE e ROSS, 2006), as quais podem ser: o tamanho físico do enlace, a

velocidade de transmissão, o valor monetário associado ao enlace, o número de saltos

(quantidade de arestas percorridas), a confiabilidade, a largura de banda disponível, a carga

aplicada ao caminho, a espera que o caminho infligirá sobre o pacote, dentre outros

(KUROSE e ROSS, 2006; GARCIA et. al., 2007).

Os algoritmos estudados neste trabalho usam apenas uma métrica para calcular o

caminho entre dois nós (SEGUÍ et. al.,2006). Essa única métrica pode ser apenas uma das

mencionadas anteriormente ou uma combinação delas (TANEMBAUM, 2003).

1.1.2 Roteamento Unicast

Em redes de computadores unicast, a comunicação se dá entre os sistemas finais

de origem e de destino (TANEMBAUM, 2003; SEGUÍ et. al., 2006). Um sistema final faz

uma requisição a outro sistema final, e este, por sua vez, envia uma resposta para o sistema

que o requisitou (comunicação ponto-a-ponto) (SEGUÍ et. al., 2006; KUROSE e ROSS,

2006).

Algoritmos de roteamento unicast são usados desde a década de 70, quando se

iniciava o desenvolvimento da Internet (TANEMBAUM, 2003; KUROSE e ROSS, 2006).

Muitos algoritmos de roteamento unicast foram desenvolvidos ao longo do tempo, atendendo

às necessidades de roteamento que foram surgindo devido à proliferação das redes e o

aumento de informações enviadas por elas (SEGUÍ et. al., 2006).

As redes também podem fazer comunicação de modo multicast ou broadcast

(TANEMBAUM, 2003). Redes multicast são aquelas em que a rede faz o roteamento de um

pacote de um nó fonte para um grupo de nós destinos. Há também a comunicação broadcast.

17

Neste tipo de rede é feito o roteamento de pacotes de um nó fonte para todos os outros nós da

rede (KUROSE e ROSS, 2006). Algoritmos de roteamento para estes tipos de rede são

baseados nos desenvolvidos para redes unicast.

Soluções diferentes e combinações de muitos algoritmos podem ser usadas para

os mais variados casos (SEGUÍ et. al., 2006). A eficiência de uma rede vai depender, dentre

outros fatores, do uso dos algoritmos adequados (CÂMARA, 2000), os quais só podem ser

descobertos com um estudo detalhado dos algoritmos disponíveis.

Para representação dessas redes e implementação dos algoritmos de roteamento, é

necessária uma estrutura de dados chamada grafo. Os algoritmos usados nas redes de

computadores foram desenvolvidos sobre essa estrutura (CORMEN et. al., 2002; KUROSE e

ROSS, 2006). A seguir são apresentados alguns conceitos referentes aos grafos.

1.2 Grafos

O conjunto de roteadores e enlaces é representado através de um grafo G=(N, A),

em que N é o conjunto de nós do grafo, não vazio, e A representa o conjunto de arestas desse

grafo, sendo que, cada aresta, é um par de nós conectados pertencentes ao conjunto N

(CORMEN et. al., 2002). Os nós correspondem aos roteadores da rede e as arestas, aos

enlaces que conectam os roteadores (KUROSE e ROSS, 2006).

Na figura 1 encontra-se um exemplo de roteadores e enlaces que os conectam.

Nesse exemplo, os roteadores são os nós u, v, w, x, y e z e cada enlace que conecta os

roteadores corresponde a uma aresta do grafo.

Várias definições da teoria dos grafos são bastante úteis no contexto de

roteamento em redes de computadores (KUROSE e ROSS, 2006), dentre eles: cadeia,

caminho, grafo ponderado, grafo orientado ou não orientado, grafo conectado ou não

conectado, matriz de adjacências e lista de adjacências.

18

1.2.1 Cadeia e Caminho

Quando um nó pode ser alcançado por outro nó ao percorrer um conjunto de

arestas, pode-se formar uma cadeia entre esses nós (CORMEN et. al., 2002). Na figura 1, o

nó z pode ser alcançado pelo nó u percorrendo as arestas (u, v), (v, w) e (w, z). Logo, há uma

cadeia de u até z: u, v, w e z. Se houver um mesmo sentido na orientação das arestas de uma

cadeia entre determinados nós, diz-se que há um caminho entre esses nós. Na figura 2 há um

caminho do nó a até o nó d.

Figura 1: Representação de uma rede através de grafo.

Fonte: KUROSE e ROSS, 2006, p. 276.

1.2.2 Grafos ponderados

A cada aresta de um grafo pode estar associado um custo, ou peso, c(x, y), o qual

indica que o grafo é ponderado (CORMEN et. al., 2002). Esse custo pode significar, por

exemplo, a distância entre dois pontos ou a carga que pode estar passando numa aresta (LIU,

LOU e FANG, 2003; GARBE, 2006). Esses custos são de grande importância na obtenção de

rotas pelos algoritmos de roteamento (KUROSE e ROSS, 2006). Na figura 1, o grafo é

ponderado e o custo c da aresta (u, w) é c(u, w) = 5. Em um grafo não ponderado, assume-se o

mesmo custo c em todas as arestas.

19

1.2.3 Grafos orientados e não orientados

Em um grafo orientado, uma aresta (x, y) Î A é diferente da aresta (y, x) Î A. A

primeira indica um caminho do nó x até o nó y, já a segunda indica um caminho no sentido

contrário que pode ter um custo diferente, ou seja, c(x, y) > c(y, x) ou c(x, y) < c(y, x)

(CORMEN et. al., 2002). Na figura 1 o grafo não é orientado. A figura 2 mostra um exemplo

de grafo orientado. Observe que há um caminho do nó a até o nó e, mas não há de e para a.

Figura 2: Grafo orientado.

1.2.4 Grafos conectados e não conectados

Um grafo é dito conectado quando pode-se alcançar qualquer nó a partir de outro

nó pertencente ao grafo (desconsiderando a orientação das arestas). Se houver um nó que não

é alcançado por outro nó do grafo, este é dito não conectado (CORMEN et. al., 2002). Os

grafos das figuras 1 e 2 são conectados.

1.2.5 Matriz de Adjacências e Lista de Adjacências

Existem duas formas tradicionais de representação computacional de grafos:

matriz de adjacências e lista de adjacências (CORMEM et. al., 2002).

Numa matriz de adjacências os nós são dispostos numa matriz quadrada em que o

número de linhas e colunas é dado pelo número de vértices do grafo. A existência de um

aresta ligando um nó i a um nó j é representada pelo valor 1 no cruzamento da linha i com a

coluna j; caso contrário (ausência de aresta), define-se valor 0. Num grafo ponderado, os

valores 0 e 1 podem ser trocados por infinito (ausência de uma aresta) e pelo peso da aresta

20

que conecta os nós, respectivamente, como pode ser visto na figura 3 (CORMEM et. al,

2002).

Figura 3: Matriz de adjacências.

Numa lista de adjacências, cada nó do grafo possui uma lista com os nós

adjacentes a ele (CORMEM et. al., 2002). A figura 4 mostra um exemplo de representação de

um grafo com uma lista de adjacências. Nota-se que há um vetor com os n vértices do grafo e

listas ligadas a cada elemento do vetor. Essas listas representam os vértices adjacentes ao

elemento do vetor correspondente.

Figura 4: Lista de adjacências.

Fonte: CORMEN et. al., 2002, p. 420.

1.3 Algoritmos de Roteamento

O propósito da camada de rede é o roteamento de pacotes de um nó fonte para um

nó de destino (TANEMBAUM, 2003), realizado pelos algoritmos de roteamento (KUROSE e

ROSS, 2006). Serão apresentados a seguir os principais algoritmos utilizados nas redes atuais.

21

1.3.1 Roteamento pelo caminho mais curto

Há vários algoritmos que calculam o caminho mais curto entre dois nós quaisquer

(CORMEN et. al., 2002). Seu cálculo é baseado nos custos dos enlaces onde se pretende

descobrir a rota que contém o menor custo (GARCIA et. al., 2007). Os principais algoritmos

discutidos na literatura que implementam esse tipo de roteamento são os algoritmos de

Dijkstra, Bellman-Ford e de Floyd (CÂMARA, 2000; TANEMBAUM, 2003).

Esses algoritmos serão detalhados no capítulo 2, onde serão mostrados os

algoritmos discutidos neste trabalho.

1.3.2 Roteamento por Inundação

O algoritmo de inundação é um algoritmo de roteamento broadcast. Nesse

algoritmo, um pacote que chega a um nó x é enviado para todos os nós conectados a x, menos

para aquele de quem x recebeu o pacote (CÂMARA, 2000). Devido a isso, ele consegue

entregar os pacotes pelo melhor caminho possível (o de menor custo), e caso haja uma falha

nesse caminho, os dados podem ser entregues através de outra rota (CÂMARA, 2000;

TANEMBAUM, 2003).

Muitas cópias do mesmo pacote são geradas por esse algoritmo, podendo

provocar congestionamento na rede. Procura-se evitar isso através de algumas medidas, como

atribuição de um tempo de vida (time to live - TTL) para cada pacote (TANEMBAUM, 2003),

que seria sua quantidade máxima de saltos (KUROSE e ROSS, 2006). Em cada roteador que

o pacote passa, seu TTL é decrementado. Quando atinge zero, o pacote é descartado

(TANEMBAUM, 2003).

Uma variação desse algoritmo é a repetição seletiva. Nele, os pacotes são

enviados apenas para os nós que provavelmente estão na direção do destino (CÂMARA,

2000; KUROSE e ROSS, 2006).

22

1.3.3 Algoritmos de vetor de distância

Esse algoritmo também é conhecido na literatura como algoritmo distribuído de

Bellman-Ford e também pode ser encontrado como algoritmo de Ford-Fulkerson (BURIOL,

2003; TANEMBAUM, 2003).

O algoritmo de vetor de distância mantém uma tabela de roteamento (vetor) com

informações dos outros nós da rede, como custos e por qual nó ele pode ser alcançado

(BOPPANA e KONDURU, 2001; TANEMBAUM, 2003; KUROSE e ROSS, 2006).

Este algoritmo é dito distribuído, pois o cálculo das rotas é feito localmente em

cada roteador. Um roteador recebe informações da mudança de custos dos seus vizinhos e

atualiza a sua tabela de acordo com as informações recebidas (BOPPANA e KONDURU,

2001). Ao modificar sua tabela, o roteador envia essa informação para os seus vizinhos

(GARBE, 2006; KUROSE e ROSS, 2006). Nisso, todos os roteadores convergem para o

cálculo das rotas de menor custo entre os pares de nós (TANEMBAUM, 2003). Esse

algoritmo também é dinâmico, pois à medida que há modificações na topologia, ele modifica

os valores de custo na tabela do roteador (KUROSE e ROSS, 2006).

Sendo d(x,y) a distância de menor custo de x até y, pela equação de Bellman-Ford,

os custos estão relacionados da seguinte forma (KUROSE e ROSS, 2006):

d(x, y) = min{c(x, v) + d(v, y)}.

A função min é calculada para todos os vizinhos de x.

1.3.4 Algoritmos de Estado de Enlace

Os algoritmos de estado de enlace são baseados no algoritmo de Dijkstra (SEGUÍ

et. al., 2006). As informações de roteamento entre os nós são enviadas para todos os nós

(GARBE, 2006). A idéia por trás desses algoritmos, segundo TANEMBAUM, 2003, p. 383,

pode ser estabelecida em cinco partes:

23

1. Descobrir seus vizinhos e aprender seus endereços de rede.

2. Medir o retardo ou o custo até cada um de seus vizinhos.

3. Criar um pacote que informe tudo o que ele acabou de aprender.

4. Enviar esse pacote a todos os outros roteadores.

5. Calcular o caminho mais curto até cada um dos outros roteadores.

Para distribuir os pacotes de estado de enlace a todos os roteadores é aplicado o

algoritmo de inundação (TANEMBAUM, 2003).

Os algoritmos de vetor de distância e de estado de enlace são os predominantes na

Internet pública atual (KUROSE e ROSS, 2006). Os protocolos de roteamento RIP (Routing

Information Protocol) e IGRP (Interior Gateway Routing Protocol) implementam o algoritmo

de vetor de distância, já os protocolos OSPF (Open Shortest Path First) e IS-IS (Intermediate

System-Intermediate System) implementam o de estado de enlace (TANEMBAUM, 2003;

KUROSE e ROSS, 2006).

SEGUÍ et. al.,2006, fornecem um diagrama que mostra a evolução dos algoritmos

de roteamento bem como dos protocolos que o implementam. Este diagrama é apresentado na

figura 5.

Do lado esquerdo da figura, nota-se que os algoritmos evoluíram a partir dos

algoritmos de Dijkstra e de Bellman-Ford. Ao lado desses algoritmos, no centro da figura,

encontram-se os protocolos que utilizam esses algoritmos. Essa figura mostra que o algoritmo

de Bellman-Ford é implementado no protocolo de roteamento RIP e o de Dijkstra, no

protocolo de roteamento OSPF. À direita encontra-se a evolução dos algoritmos “ótimos”.

1.3.5 Roteamento Ótimo

Em algoritmos de roteamento ótimo não se procura o caminho mais curto para um

destino, mas a otimização da média global de espera de uma rede. Dependem de parâmetros

globais que são difíceis de conhecer à priori e convergem lentamente, mas tem inspirado o

desenvolvimento de alguns protocolos (SEGUÍ, et. al., 2006).

24

Figura 5: Evolução do desenvolvimento dos algoritmos de roteamento.

Fonte: SEGUÍ, et. al., 2006.

1.3.6 Algoritmos com Parâmetros de Qualidade de Serviço (QoS)

Qualidade de serviço é uma necessidade nas redes atuais, principalmente devido

ao crescimento de aplicações de tempo real (LORENZ et. al., 2006; MOHSENI, VAHEDI e

NADERI, 2007). Nos últimos anos foram desenvolvidos algoritmos que possuem parâmetros

de qualidade de serviço, sendo que várias métricas são definidas para eles (LIU, LOU e

FANG, 2003), tais como: largura de banda, espaço de buffer, espera, confiabilidade e

throughput (KOUNDINYA, NEGI e SASTRY, 2004). Dentre esses algoritmos encontram-se

o WSP (Widest Shortest Path), o SWP (Shortest Widest Path) e o MRBHP (Maximum Ratio

of Bandwidth and Hop Path) (SEGUÍ, et. al., 2006; MOHSENI, VAHEDI e NADERI, 2007).

1.3.7 Algoritmos para Redes Móveis Ad-hoc

Uma área especial das redes de computadores são as redes móveis Ad-hoc (Mobile

Ad-hoc Networks - MANETs) (TANEMBAUM, 2003). Essa área tem crescido bastante nos

últimos anos, ganhando atenção especial de diversos pesquisadores.

25

Algoritmos para MANETs têm que lidar com o dinamismo das conexões,

variações na localização dos nós e outros fatores que são comuns a dispositivos móveis

(MOHSENI, VAHEDI e NADERI, 2007). Esses algoritmos são comumente classificados em:

· Proativos: calculam as rotas entre os nós regularmente, mesmo não sendo requisitado

para isso. Mantém sempre uma lista atualizada de rotas (SEGUÍ et. al., 2006);

· Reativos: calculam as rotas entre pares de nós que precisam se comunicar (COSTA,

AMORIM e FDIDA, 2003; SEGUÍ et. al., 2006);

· Híbridos: são proativos e reativos (SEGUÍ et. al., 2006).

Os principais algoritmos para MANETs são:

I – DSR (Dynamic Source Routing): baseado em roteamento por fonte, toda a rota é

determinada a partir de um nó (SEGUÍ et. al., 2006). É um algoritmo reativo (CÂMARA,

2000; SEGUÍ et. al., 2006);

II – AODV (Ad-hoc On-Demand Distance Vector): é um algoritmo reativo baseado no vetor

de distâncias (BOPPANA e KONDURU, 2001; TANEMBAUM, 2003);

III – GSR (Global State Routing): é baseado no estado de enlace. Procura diminuir o consumo

de banda da rede (CÂMARA, 2000);

IV – TORA (Temporally-Ordered Routing Algorithm): procura minimizar o impacto das

mudanças de topologia na rede, fornecendo múltiplas rotas para um destino (CÂMARA,

2000; SEGUÍ et. al., 2006);

V – OLSR (Optimized Link State Routing): esse é um algoritmo proativo. Mantém sempre

uma lista de rotas para todos os destinos possíveis, mesmo não sendo requisitado (SEGUÍ et.

al., 2006);

VI – ZRP (Zone Routing Protocol): é um algoritmo híbrido, procurando aumentar a eficiência

e escalabilidade no cálculo das rotas (MOHSENI, VAHEDI e NADERI, 2007). A partir de

cada nó, define uma zona de roteamento (CÂMARA, 2000);

VII – LAR (Location-Aided Routing): é baseado na posição geográfica dos nós para o

roteamento, calculando a zona onde se encontra o destino (MOHSENI, VAHEDI e NADERI,

2007).

26

Figura 6: Alguns algoritmos MANETs.

Fonte: SEGUÍ, et. al., 2006.

Na figura 6 são apresentados alguns algoritmos MANETs, divididos em proativos,

reativos e híbridos.

1.4 Classificação dos algoritmos de roteamento

Na literatura de redes, os algoritmos de roteamento possuem várias formas de

classificação. Cada tipo de classificação reflete as características e funcionamento que são

peculiares aos algoritmos (CÂMARA, 2000; KUROSE e ROSS, 2006). Isso será de grande

valia na análise dos algoritmos, pois eles podem ser analisados de acordo com essas

peculiaridades nos diversos ambientes que existem nas redes de computadores

(TANEMBAUM, 2003).

Os algoritmos podem ser classificados da seguinte forma:

1.4.1 Estático ou Dinâmico

Algoritmos de roteamento estático calculam as rotas entre os nós uma vez em sua

primeira execução e não são mais executados a não ser por alguma intervenção. Não são

sensíveis aos tráfegos da rede nem à sua topologia. Modificam muito lentamente as rotas na

rede (CÂMARA, 2000; KUROSE e ROSS, 2006).

27

Já os algoritmos de roteamento dinâmico são sensíveis ao tráfego e à topologia da

rede, modificando as rotas à medida que o cenário da rede é alterado (KUROSE e ROSS,

2006).

1.4.2 Global ou Descentralizado

Roteadores que executam algoritmos de roteamento globais precisam ter

conhecimento de todos os nós da rede. O cálculo das rotas é feito em cada roteador, os quais

procuram, através de mensagens, conhecer quais os roteadores que fazem parte da rede

(GARBE, 2006; KUROSE e ROSS, 2006).

Os algoritmos descentralizados, por sua vez, não precisam ter conhecimento

global da rede. Cada roteador procura obter o caminho de menor custo trocando informações

de custos com os roteadores “vizinhos” (BOPPANA e KONDURU, 2001). À medida que os

dados de roteamento se modificam, o roteador envia essa informação para os nós vizinhos, os

quais modificam seus dados e os passam para os outros nós (KUROSE e ROSS, 2006).

1.4.3 Sensíveis à carga ou insensíveis à carga

Os algoritmos podem ser sensíveis ao congestionamento em que se encontra à

rede. Os sensíveis à carga procuram obter um caminho de menor congestionamento na rede.

Já os insensíveis à carga calculam as rotas sem verificar a situação do tráfego de dados na

rede (KUROSE e ROSS, 2006).

1.4.4 Caminhos mínimos e caminhos múltiplos

Os algoritmos podem suportar vários caminhos para um mesmo destino. Baseado

em alguma heurística, o algoritmo escolhe um desses caminhos para os pacotes, procurando

balancear a carga entre os enlaces (GARBE, 2006). Algoritmos de caminhos mínimos obtêm

apenas uma rota, a saber, a de menor custo (CÂMARA, 2000; GARBE, 2006).

Algoritmos de caminhos múltiplos não serão discutidos neste trabalho.

28

1.4.5 Planos ou hierárquicos

Os algoritmos também podem ser agrupados como planos ou hierárquicos. No

sistema de roteamento plano, os nós são considerados como pares uns dos outros, não

existindo subdivisões entre eles (CÂMARA, 2000). Já nos hierárquicos, os roteadores são

divididos em regiões, chamadas de sistemas autônomos (KUROSE e ROSS, 2006). Cada

região é independente da outra na execução dos algoritmos de roteamento. Quando um pacote

tem que ser enviado para fora da região, utiliza-se um roteador de borda, o qual envia o pacote

para a região apropriada (TANEMBAUM, 2003; KUROSE e ROSS, 2006).

Neste trabalho os algoritmos serão simulados em ambientes que formam uma

única região, não fazendo referência para nós de outra região.

1.5 Propriedades dos Algoritmos de Roteamento

Segundo TANEMBAUM, 2003, p. 373, algumas propriedades são desejáveis para

os algoritmos de roteamento. Essas propriedades são “correção, simplicidade, robustez,

estabilidade, equidade e otimização”.

Após esse embasamento teórico, pode-se seguir para o próximo capítulo. Nele

serão apresentados e discutidos os algoritmos considerados neste trabalho.

29

2 ALGORITMOS DE ROTEAMENTO UNICAST

Nesta seção serão apresentados os algoritmos considerados neste trabalho. Serão

apresentados fatores como implementação, complexidade algorítmica e características de

aplicabilidade.

Esses algoritmos são usados na implementação dos protocolos de roteamento

unicast (SEGUÍ et. al., 2006). Está fora do escopo deste trabalho descrever os protocolos que

utilizam esses algoritmos.

Esses algoritmos foram escolhidos de acordo com a sua importância no

roteamento de pacotes na rede ou porque introduziram melhorias em algoritmos pré-existentes

e muito utilizados.

Os algoritmos escolhidos foram:

· algoritmo de Dijkstra executado de forma estática;

· algoritmo Estendido de Dijkstra;

· algoritmo de Floyd-Warshall;

· algoritmo de roteamento por Estado de Enlace e;

· algoritmo de roteamento por Vetor de Distância, também denominado algoritmo

distribuído de Bellman-Ford (TANEMBAUM, 2003).

30

2.1 O Algoritmo de Dijkstra

A forma mais tradicional de roteamento é encontrar o caminho mais curto entre

dois nós. O algoritmo de Dijkstra é o mais utilizado para isso, devido a sua simplicidade e

eficiência (GARCIA et. al., 2007).

Para que ele encontre o caminho mais curto entre os nós, um administrador de

rede deve informar a topologia da rede e o custo dos enlaces. Quando esses dados são

definidos, o algoritmo é aplicado para cada roteador. Assim, esse algoritmo de roteamento é

aplicado de forma estática. Ao ser definido o caminho, ele não é mais alterado, a não ser que o

administrador de rede forneça novos dados e execute novamente o algoritmo

(TANEMBAUM, 2003). Assim, ele também é um algoritmo de roteamento não sensível à

carga.

No algoritmo de Dijkstra, a partir de um nó de origem s, consegue-se encontrar a

menor rota até todos os outros nós da rede, quando os custos não são negativos (CORMEN et.

al., 2002; GARCIA et. al., 2007). Esse algoritmo inicia a distância de cada um dos nós até a

origem s: se um nó v é vizinho de s, então a distância inicial dele é conhecida, sendo o valor

associado à aresta (s, v); senão, sua distância inicial é infinita. A cada iteração é escolhido,

dentre todos os nós, o nó w que tem a menor distância até a origem s, sendo esse valor não

mais alterado até se encontrar a rota desejada. Então é verificada se a distância de cada nó v

adjacente a w, que não teve seu valor fixado anteriormente como sendo a menor, pode ser

melhorada. Isso é feito calculando se distância atual de v é menor do que a distância atual de

w mais o custo de w até v. O menor valor será a distância associada a v (CORMEN et. al.,

2002; KUROSE e ROSS, 2006). Também é informado o predecessor de cada nó. Se a

distância de v for atualizada, o predecessor será w.

O pseudocódigo para esse algoritmo é apresentado na figura 7.

31

Figura 7: Pseudocódigo do algoritmo de Dijkstra.

Neste algoritmo existe uma fila de prioridades que contém os nós que ainda não

tiveram seus valores de distância e predecessor fixados. Dela extrai-se o nó com o menor

custo para fazer parte do caminho mínimo (CORMEN et. al., 2002).

Como exemplo da execução desse algoritmo, considere a rede apresentada na

figura 8. Essa rede é formada por seis nós e será apresentada a execução do algoritmo no

roteador a, ou seja, serão encontrados os caminhos mais curtos até todos os nós a partir do

roteador a.

Figura 8: Rede com seis roteadores modelada como um grafo. O nó a é a origem.

Fonte: TANEMBAUM, 2003, p. 377.

Na fase de “inicialização”, os nós b e g têm distâncias de 2 e 6 a partir da origem,

respectivamente, e a como predecessor. Todos os outros nós têm distâncias infinitas e

32

predecessores nulos. A origem a tem distância igual a 0 e não tem predecessor. Todos os nós

estão na fila de espera para terem seus valores fixados.

Na primeira iteração, a origem é adicionada ao caminho, pois tem a menor

distância até a origem (obviamente começa-se pela origem). Os vizinhos de a já foram

“inicializados”, e não há alteração na primeira iteração. Na segunda iteração, o nó b é o que

tem a menor distância. Então ele é retirado da fila e adicionado à lista de caminho mais curto

e, logo após, verificam-se todos os vizinhos de b que estão na fila: c e e. Como a distância de

b mais o custo de b até seus vizinhos é menor que a distância dos vizinhos, a distância de c é

alterada para 9 e a de e para 4. Eles terão b como predecessor.

Na próxima iteração, e terá a menor distância, e os mesmos passos serão

realizados para ele e em seguida para os demais nós, até a fila ficar vazia. A figura 9 ilustra

esses passos para encontrar as menores distâncias de a para todos os destinos. A seta indica o

último nó que foi adicionado à lista de caminho mais curto.

Segundo CORMEN et. al., 2002, o tempo de execução do algoritmo de Dijkstra

depende de como a fila de prioridades mínima mostrada no pseudocódigo é implementada. O

tempo de execução, no pior caso, desse algoritmo é da ordem de O(n²), em que n é o número

de nós. Com uma boa implementação da fila de prioridades e dependendo da topologia do

grafo, esse tempo poderá ser reduzido. Para mais detalhes, veja CORMEN et. al., 2002, p.

473 e 474, onde mostra-se que, com a implementação “da fila de prioridade mínima com um

heap de Fibonacci”, pode-se alcançar um tempo de execução igual a O(nlgn + a), em que a é

o número de arestas do grafo.

33

Figura 9: Execução do algoritmo de Dijkstra com origem no nó a.

Fonte: TANEMBAUM, 2003, p. 377, com adaptações.

2.2 Algoritmo Estendido de Dijkstra

GARCIA et. al., 2007, apresentam uma melhoria do algoritmo de Dijkstra: o

algoritmo Estendido de Dijkstra. Essa melhoria é específica para topologia de redes que

forma anéis. O algoritmo de Dijkstra tradicional encontra sempre o mesmo e único caminho a

partir de um nó, dada a mesma topologia, independente da sobrecarga dos enlaces e

desbalanceamento da rede. Mas topologias em anel permitem um nível adicional de

conectividade para cada nó, ou seja, há dois caminhos possíveis para se chegar ao destino,

34

com o custo de um único enlace adicional. Esse tipo de topologia é comum em redes ópticas,

como a Rede Óptica Européia (European Optical Network – EON) mostrada na figura 10.

Segundo GARCIA et. al., 2007, devido à natureza iterativa do algoritmo de

Dijkstra, em redes que incluem enlaces que criam anéis (e.g., a sub-rede de quatro nós em

anel da figura 10 formada por Amsterdam, Berlim, Praga e Luxemburgo), o algoritmo de

Dijkstra tende a escolher muitos caminhos sobre um mesmo enlace e poucos em outros

mesmo havendo outros caminhos igualmente menores, tornado a carga da rede desbalanceada.

Figura 10: Parte da Rede Óptica Européia. Várias sub-redes em anéis podem ser formadas com esses nós.

Fonte: GARCIA et. al., 2007.

Para solucionar esse problema, é proposta uma melhoria no algoritmo para que

haja uma distribuição homogênea do número de rotas e caminhos pelos enlaces disponíveis,

melhorando o balanceamento e a simetria (pacotes passando por um mesmo enlace, mas em

sentidos opostos) na distribuição da carga.

Esse algoritmo introduz um novo conceito ao grafo usado pelo algoritmo de

Dijkstra: cada nó é identificado por um número único, denominado identificador do nó. Essa

extensão detecta possíveis custos iguais por caminhos diferentes e utiliza o identificador do nó

para selecionar uma ou a outra rota.

35

Considere identificador(u) como o identificador de um determinado nó u e

identificadores(u) como todos os identificadores dos nós conectados ao nó u. A figura 11, a

seguir, mostra o trecho de código que é incluído no algoritmo de Dijkstra, após a fase de

escolha do nó com menor custo mostrado na linha 11 da figura 7.

Figura 11: Trecho incluído no algoritmo de Dijkstra para melhorar o balanceamento e simetria no

roteamento em topologias de rede em anel.

A figura 12 ilustra a aplicação de duas implementações distintas do algoritmo de

Dijkstra e do algoritmo estendido sobre uma rede em anel de 4 nós com as rotas escolhidas

para cada enlace.

Figura 12: Figuras (a) e (b) mostram as rotas na execução de duas implementações distintas do algoritmo

de Dijkstra. A figura (c) ilustra a execução do algoritmo Estendido de Dijkstra.

Fonte: GARCIA et. al., 2007.

Veja que, na aplicação do algoritmo proposto (figura 2.6(c)), há um melhor

balanceamento e simetria das rotas escolhidas. Segundo GARCIA et. al., 2007, essa diferença

tem maior impacto em redes que formam anéis com número de nós pares, devido a existência

de dois caminhos igualmente menos custosos entre dois nós diametricalmente opostos.

36

2.3 Algoritmo de Floyd-Warshall

O algoritmo de Floyd-Warshall resolve o problema de encontrar o caminho mais

curto entre todos os pares de nós. Ele considera nós intermediários entre cada par a fim de

melhorar o custo entre os pares (CORMEN et. al., 2002). Dado, por exemplo, três nós x, y e z,

ele verifica se o custo de x até z é menor do que o custo de x até y mais o de y até z. Para a

obtenção da rota ele também mantém as informações dos predecessores dos nós. No exemplo

dado, se o menor caminho é de x até z, então o predecessor de z é x, caso contrário é y. Esse

algoritmo recebe uma matriz de adjacência como entrada.

Segundo CORMEN et. al., 2002, a complexidade desse algoritmo é de ordem

cúbica, sendo o tempo de execução, no pior caso, O(n³), portanto, menos eficiente que o

algoritmo de Dijkstra.

O pseudocódigo da figura 13 descreve esse algoritmo:

Figura 13: Pseudocódigo do algoritmo de Floyd-Warshall.

2.4 Algoritmo de Roteamento por Vetor de Distância

O algoritmo de vetor de distância foi o algoritmo utilizado na ARPANET até o

final da década de 1970 (TANEMBAUM, 2003). Segundo KUROSE e ROSS, 2006, ele “é

utilizado em muitos protocolos de roteamento na prática”, como o RIP (Routing Information

Protocol – Protocolo de Informação de Roteamento) e o BGP da Internet (Border Gateway

Protocol – Protocolo de Roteamento de Borda). Além disso, muitos outros protocolos e

37

algoritmos de roteamento utilizados no roteamento de MANETs e redes com parâmetros de

QoS se baseiam nele (LIU, LOU e FANG, 2003; SEGUÍ et. al., 2006).

O algoritmo de vetor de distância faz com que cada roteador tenha uma tabela

(matriz) indexada com cada roteador da rede. A cada índice é associado a linha de saída que

um pacote deverá ser repassado para um destino e o custo associado até esse destino. Quando

sua tabela é alterada, o roteador envia para os vizinhos as estimativas de custo até cada

destino. Ele também recebe de seus vizinhos a estimativa que eles possuem para que a

estimativa local seja ou não atualizada (TANEMBAUM, 2003; KUROSE e ROSS, 2006).

Este algoritmo é descentralizado, pois não precisa conhecer a topologia completa

da rede, mas consegue convergir para o menor caminho através de troca de informações com

os vizinhos. Ele também é dinâmico e sensível à carga, pois alterações no custo dos enlaces

ou na topologia da rede são percebidas e influem na escolha dos melhores caminhos. Outra

característica é que os roteadores podem calcular as rotas assincronamente (KUROSE e

ROSS, 2006).

Como mostrado na seção 1.3.3, a atualização de uma estimativa de custo para um

destino é atualizada segundo a equação de Bellman-Ford (KUROSE e ROSS, 2006):

d(x, y) = min{c(x, v) + d(v, y)}.

Essa equação, calculada para cada um dos vizinhos de x, informa que a distância

mínima entre a origem x e o destino y corresponde ao mínimo do custo dos vizinhos de x

adicionado à distância destes vizinhos à y. Após o cálculo dessa equação, sabe-se

precisamente qual o roteador de próximo salto a partir de x.

Quando o roteador recebe uma tabela de um de seus vizinhos, o algoritmo verifica

se o custo para cada destino pode ser melhorado. Se puder ser melhorado, a tabela do roteador

é atualizada e as novas informações são repassadas para os seus vizinhos.

Cada nó de uma rede, além de manter o seu vetor de distância, também armazena

o vetor de distância de cada um de seus vizinhos (KUROSE e ROSS, 2006).

38

Na figura 14, é apresentado um pseudocódigo que mostra a idéia do algoritmo de

roteamento por vetor de distância.

Figura 14: Algoritmo de vetor de distância.

Existe um problema nesse algoritmo que torna a convergência do cálculo correto

de menor custo das rotas entres os nós muito demorado: o problema da contagem ao infinito.

Esse é um problema causado quando há um aumento elevado no custo de algum enlace como

mostrado na figura 15.

Figura 15: Alteração no custo do enlace (x, y) provocando problema de contagem ao infinito.

Fonte: KUROSE e ROSS, 2006, p. 285.

39

Inicialmente, os custos dos enlaces estão divididos da seguinte forma: c(x, y) = 4,

c(y, x) = 4, c(y, z) = 1, c(z, y) = 1, c(z, x) = 50 e c(x, z) = 50. Então há uma mudança no custo

do enlace que liga os nós x e y de 4 para 60. Com essa alteração, tomando como exemplo

apenas o cálculo dos nós y e z para x, o nó y calcula o caminho para x como sendo de custo 6,

já que tem a informação do nó z de que este tem o custo até x igual a 5. Como y não sabe que

faz parte deste caminho calculado por z (nesse instante, y direciona pacotes com destino a x

para z, e z para y, provocando loops de roteamento), ele altera o seu vetor e manda a

informação para os seus vizinhos. Quando z recebe as alterações do vetor de y, ele vê que este

tem um caminho para x com custo igual a 6. Como seu custo até y é 1, atualiza seu custo até x,

para 7, passando por y. O nó z também não sabe que ele está nesse caminho calculado por y.

Esse problema vai persistir até o momento em que z receber a informação de que c(y, x) = 51.

Segundo TANEMBAUM, 2003, o “núcleo do problema” está no fato de um nó não saber se

faz parte de um caminho cujo custo foi alterado por seu vizinho.

O problema apresentado faz com que esse algoritmo, no pior caso, tenha um custo

muito elevado (KUROSE e ROSS, 2006).

2.5 Algoritmo de Roteamento por Estado de Enlace

O algoritmo de roteamento por estado de enlace foi implementado como

substituto do algoritmo de vetor de distância no final da década de 1970 para resolver alguns

dos problemas que este causava, como a demora de convergência (TANEMBAUM, 2003).

Muitos protocolos implementam esse algoritmo atualmente e são amplamente usados (SEGUI

et. al., 2006; KUROSE e ROSS, 2006). Alguns desses protocolos são o OSPF (Open Shortest

Path First – Primeiro Caminho Mais Curto Livre) e o IS-IS (Intermediate System-

Intermediate System – Sistema Intermediário-Sistema Intermediário). O OSPF é amplamente

utilizado na Internet (TANEMBAUM, 2003).

O algoritmo de estado de enlace é um algoritmo dinâmico e global. Ele procura

conhecer toda a topologia da rede e os custos de todos os enlaces e depois encontra o menor

caminho até cada um dos nós (BURIOL, 2003).

Como mostrado na seção 1.3.4, em cada nó, o algoritmo de estado de enlace

verifica quais são os seus vizinhos e o custo de cada enlace que os conectam. O nó então cria

40

e envia pacotes de estado de enlace para todos os outros nós da rede. Esses pacotes contêm os

vizinhos do nó e os custos de cada enlace ligado a ele (TANEMBAUM, 2003; KUROSE e

ROOS, 2006).

A transmissão dos pacotes é feita com um algoritmo de broadcast como o

algoritmo de Inundação (TANEMBAUM, 2003) apresentado na seção 1.3.2. Com isso, todos

os nós da rede terão uma visão idêntica e completa da topologia da rede (KUROSE e ROSS,

2006). Após isso, pode-se aplicar o algoritmo de Dijkstra em cada nó para calcular o caminho

de menor custo até todos os outros nós (TANEMBAUM, 2003).

KUROSE e ROSS, 2006, apresentam uma patologia que pode ocorrer com esse

algoritmo e com qualquer outro que utilize uma métrica baseada no congestionamento ou em

atraso. Quando um pacote é enviado de um nó para outro, na próxima iteração para o cálculo

das rotas, os nós detectam que há outro caminho que possui um custo menor, ocasionando

uma oscilação no roteamento. Isso é demonstrado na figura 16.

Figura 16: Oscilações que podem ocorrer com o roteamento por estado de enlace quando se usam

métricas baseada no congestionamento ou no atraso. Fonte: KUROSE e ROSS, 2006, p. 280.

41

A figura 16(a) mostra como é o roteamento inicialmente, com os nós x, y e z

enviando dados para o nó w. A figura 16(b) mostra que x e y detectaram que o melhor

caminho até w estava no sentido horário e em 16(c) o roteamento passa a ser no sentido anti-

horário. Essa oscilação persistirá até que o tráfego termine.

Esse algoritmo tem a complexidade de O(n²) (KUROSE e ROSS, 2006).

No próximo capítulo serão apresentados o simulador ns-2, utilizado neste

trabalho, e os cenários utilizados para as simulações dos algoritmos de roteamento unicast.

42

3 SIMULAÇÃO

Neste capítulo é apresentado o simulador Network Simulator-2 utilizado para

simulação em redes de computadores. Também serão apresentadas as topologias e os cenários

utilizados para a realização da simulação.

3.1 O Simulador Network Simulator-2

O Network Simulator-2, (ns-2) (The Network Simulator - ns-2, 2009) é um

software de simulação de redes de computadores escrito em C++ mantido pelo projeto VINT,

que é uma colaboração entre pesquisadores da Universidade de Berkeley, LBNL, USC/ISI e

Xerox PARC para desenvolvimento desse simulador (FALL e VARADHAN, 2009). Ele dá

suporte para vários tipos de roteamento, incluindo bibliotecas para roteamento unicast,

multicast e MANETs. Nele podem ser construídos diferentes cenários de rede e variações de

tráfegos de pacotes para execução do algoritmo de roteamento. Ele está em constante

desenvolvimento, recebendo contribuições de diversos pesquisadores e desenvolvedores de

software (FALL e VARADHAN, 2009). Foi utilizada, neste trabalho, a versão 2.33 desse

simulador.

A topologia de uma rede e todo o ambiente para simulação, no ns-2, são

construídos através de uma linguagem interpretada orientada a objetos chamada Otcl, a qual

usa um interpretador para execução dos scripts. O arquivo que contém o script de simulação

tem a extensão .tcl. A estrutura do ns-2 e os algoritmos de roteamento são escritos em C++

(FALL e VARADHAN, 2009).

43

A razão de se usar duas linguagens no ns-2 é a necessidade de uma linguagem que

permita rápida alteração do cenário de simulação sem ter que compilar todo o código,

conseguida com o Otcl, e eficiência e precisão na execução da simulação, conseguida com o

C++. Cada objeto do simulador é disponibilizado para o interpretador por linkagem (FALL e

VARADHAN, 2009).

A saída gerada pela execução do arquivo tcl pode ser enviada para dois outros

arquivos: um com extensão .nam e outro com extensão .tr. O primeiro tipo de arquivo é usado

pelo Network Animator (nam), que é um software para visualização gráfica dos cenários e dos

fluxos dos pacotes pela rede. Através do nam, pode-se ver o tráfego de pacotes, interagir com

a simulação (e. g. avançar, parar, voltar), além de outras funcionalidades úteis para extração

de informações da simulação. Já o segundo arquivo armazena os traces gerados pela execução

da simulação. Esses traces são os registros de dados de cada evento que ocorre na simulação

para posterior análise (FALL e VARADHAN, 2009).

Ao executar o script de simulação, pelo comando ns <nome_arquivo>, em que

nome_arquivo é o arquivo tcl com o script de construção dos cenários, os passos gerados

devem ser enviados para um arquivo com extensão .nam para ser visualizado com o Network

Animator. A estrutura básica para simulação é mostrada na figura 17.

A primeira tarefa necessária nos scripts é criar o objeto simulador que será

executado (GREIS, 2000). Isso é feito no script através do comando mostrado na linha 2 da

figura 17. Na linha 5 é aberto um arquivo onde ficarão os traces gerados pelo simulador para

posterior avaliação, dito na linha 6. Ele foi chamado de saída_trace.tr. Seu manipulador é o

objeto f. Na linha 8 foi aberto o arquivo saída_nam.nam onde será colocado o trace para

posterior execução da simulação no Network Animator. Esse arquivo é passado para o

manipulador de arquivos nf. Na linha 9 é dito para o simulador escrever os dados de

simulação relevantes para o nam no arquivo aberto.

Para que os arquivos sejam fechados e seja iniciada a animação da simulação

através do nam, na linha 12 é criada uma procedure que será chamada no final da execução da

simulação e do preenchimento dos traces pelo ns. Veja que na linha 17 o nam é executado.

44

Figura 17: Exemplo de script de simulação.

A partir da linha 21 é construído o cenário de simulação. As linhas 21, 22 e 23

constroem três nós, os roteadores. Na linha 26, é criado um enlace duplo entre os nós n0 e n1,

com uma banda de 1Mbit/s, espera na fila de 10 milissegundos e o tipo de fila em que o

pacote que estiver na cauda será descartado após o tempo máximo de espera. Na linha 27, é

criado um enlace entre os nós n1 e n2 com essas mesmas características. Em seguida, na linha

30, é criado um agente UDP que enviará dados pela rede e na linha 31 ele é anexado ao nó n0.

Esse agente, da camada de transporte, indica como é feito o tratamento do fluxo dos dados.

Nesse caso, as características de transporte é a do “melhor esforço”, seguida pelo protocolo

UDP (KUROSE E ROSS, 2006). Nas simulações que serão realizadas na seção 3.3 também

45

haverá tráfegos TCP, o qual fornece serviços de entrega confiável de dados, controle de fluxo

e controle de congestionamento (KUROSE E ROSS, 2006). Nesses casos, poderá haver

momentos em que o tráfego diminuirá e pacotes de reconhecimento aparecerão nos traces.

Nas linhas 34 a 37, é criado e configurado o tráfego gerado pelo agente UDP. O

tipo de tráfego gerado na camada de aplicação é o CBR (Constant Bit Rate – Taxa de Bits

Constante). O tamanho de cada pacote é de 500 bytes. Cada pacote será enviado pela rede a

cada 5 milissegundos. Nas simulações deste trabalho, também serão gerados tráfegos na

camada de aplicação pelo FTP, que enviará dados para o protocolo TCP.

Na linha 40 é criado o agente que recebe o tráfego do agente UDP. Esse agente é

Null, pois só recebe dados. Ele é anexado ao nó n2. Portanto o fluxo dos pacotes será do nó n0

ao nó n2, passando pelo nó n1. Na linha 44 é feita a conexão entre os agentes. Em nós que

recebem dados por agente TCP deve ser criado um agente TCPSink (FALL e VARADHAN,

2009).

O ns-2 permite que sejam feitos agendamentos de transmissões de dados. Na linha

47 é informado que o tráfego só será iniciado após 0,5 segundos do início da execução. Esse

tráfego será interrompido após 4,5 segundos. Também é agendado, na linha 51, o momento

em que a procedure finish é chamada.

Finalmente, na linha 54, a simulação é executada. Após sua finalização, os traces

gerados estão prontos para análise e pode-se visualizar a simulação através do nam, como

mostra a figura 18.

Figura 18: Execução do cenário apresentado: três nós com um fluxo saindo do nó 0 ao nó 2.

46

O arquivo com extensão .tr gerado pela simulação contém informações úteis para

entendimento do processo de simulação. Cada linha desse arquivo contém a descrição de um

evento em determinado instante (FALL e VARADHAN, 2009). Esses eventos e suas

classificações são apresentados na tabela 1.

Tabela 1: Eventos que podem aparecer num arquivo trace .tr.

+ Pacote entrou na fila

- Pacote saiu da fila

r Pacote recebido

d Pacote descartado

Como pode ser visto na figura 19, cada linha de um arquivo de trace pode ter

várias colunas. A primeira coluna identifica o evento que ocorreu; a segunda coluna informa o

instante em que ocorreu o evento; a terceira e quarta coluna informam por quais nós

adjacentes aconteceu o evento; a quinta coluna identifica o tipo de tráfego que passou nesse

instante entre os nós; a coluna tracejada é reservada para flags de alguns protocolos; a sétima

coluna é um identificador do fluxo IPv6; a oitava e nona coluna informam o endereço de fonte

e de destino do pacote, respectivamente; a décima coluna é o número de sequência do pacote

e, a décima primeira informa o identificador único do pacote.

Figura 19: Algumas linhas do trace gerado pelo ns-2.

O exemplo apresentado será o modelo usado nas simulações dos algoritmos de

roteamento. Serão acrescentados nós, enlaces e configurações de tráfego de forma semelhante

ao apresentado, além da declaração de qual algoritmo de roteamento será utilizado.

A seguir são descritos os cenários que foram utilizados para as simulações.

47

3.2 Topologia e Ambiente de Simulação

Para a simulação dos algoritmos de roteamento, foram utilizadas duas redes: uma

é baseada na Rede Abilene, mostrada na figura 20 que, apesar de ser uma rede de backbone de

alto desempenho utilizada para interligar várias instituições (DODGE, 2004), foi utilizada

com uma largura de banda de 5Mbit/s para efeito de simulação; a outra é baseada na rede da

figura 1.

Para a primeira rede foram, inicialmente, configurados quatro tráfegos com fontes

e destinos diferentes. Dois tráfegos são gerados através de agentes TCP: uma com tráfego

FTP de fonte no nó 2 e destino no nó 11; outro com tráfego CBR, com fonte no nó 5 e destino

no nó 9. Outros dois tráfegos CBR são gerados através de agentes UDP: um com fonte no nó

0 e destino no nó 4 e outro com origem no nó 6 e destino no nó 1. Uma simulação é feita sem

nenhuma alteração nos enlaces da rede. Depois, para verificar o dinamismo dos algoritmos, os

enlaces (2, 3), (8, 9) e (4, 5) ficarão indisponíveis durante certo período de tempo. Todos os

enlaces têm o mesmo custo.

Após essas simulações, foram feitas outras simulações sobre essa primeira rede de

alguns problemas que os algoritmos podem enfrentar durante o roteamento de pacotes:

oscilação, loops e contagem ao infinito.

Para simular o problema da oscilação no roteamento, os enlaces (9, 8) e (3, 4)

ficaram alternadamente indisponíveis entre os intervalos 10 segundos e 50 segundos a cada 1

segundo.

Para simular o problema dos loops e contagem ao infinito, colocaram-se mais três

tráfegos sobre essa rede: dois tráfegos CBR gerados por agentes UDP entre os nós 1 e 7 e

entre os nós 7 e 0, e um tráfego FTP sobre um agente TCP entre os nós 6 e 10. Foi, então,

programada a perda dos enlaces (10, 9) e (1, 2) entre os intervalos 15s e 30s, isolando os

enlaces 0, 1 e 10 dos demais nós. Assim as distâncias para esses nós passaram a ser infinitas.

48

Figura 20: Rede Abilene, parte do projeto da Internet 2.

Fonte: DODGE, 2004.

O script completo dessa rede encontra-se no apêndice I deste trabalho. A figura 21

mostra a rede gerada pelo nam.

Figura 21: Primeira rede usada na simulação gerada pelo nam

Para a segunda rede foram escolhidos três tipos de cenários. Dois terão apenas

dois tráfegos: no primeiro não há modificação nos custos dos enlaces durante toda a

simulação e, no segundo, o enlace (3, 4), onde se concentra a maior parte do tráfego, ficará

indisponível durante 15s. Nesses cenários, o tráfego ocorrerá entres os nós 0 e 5 e entre os nós

1 e 4. O primeiro tráfego, CBR, é gerado por um agente UDP e no outro, o FTP gera tráfego

para um agente TCP.

49

No terceiro cenário, a fim de aumentar a carga de tráfego na rede para ver o seu

comportamento, serão gerados 6 tráfegos: 3 por agentes UDP entre os nós 0 e 2, 4 e 1 e, 2 e 1;

e 3 para agentes TCP entre os nós 1 e 5, 5 e 0 e, 5 e 3.

Para esses cenários os custos dos enlaces são os mesmos. São eles, nos dois

sentidos: c(0, 1) = 2; c(0, 2) = 5; c(0, 3) = 1; c(1, 2) = 3; c(1, 3) = 2; c(2, 3) = 3; c(2, 4) = 1;

c(2, 5) = 5; c(3, 4) = 1 e; c(4, 5) = 2.

O script completo desses cenários é apresentado no apêndice II. A figura 22

mostra a rede desenhada pelo nam com a execução do trace gerado pelo ns-2 através do

script.

Figura 22: Segunda rede usada na simulação gerada com o nam

O tempo de simulação para cada cenário dessas redes foi de 60 segundos.

No próximo capítulo serão descritas as simulações realizadas sobre os algoritmos

predominantes no roteamento de redes unicast para demonstração e entendimento do

funcionamento desses algoritmos. Esses algoritmos são o algoritmo estático de Dijkstra, o

algoritmo de Estado de Enlace e o algoritmo de Vetor de Distância.

50

4 SIMULAÇÃO DOS ALGORITMOS DE ROTEAMENTO

As simulações foram realizadas com três dos algoritmos apresentados no capítulo

2. Elas visam dar um bom entendimento prático do funcionamento quando os algoritmos são

executados. Esses algoritmos são: algoritmo de Dijsktra, algoritmo de Estado de Enlace e

algoritmo de Vetor de Distância.

O ns-2 fornece a implementação desses algoritmos. Por padrão, o roteamento no

ns-2 é feito de forma estática utilizando o algoritmo de Dijkstra. Assim, se não for informado

nenhum algoritmo específico para ser executado, será aplicado o algoritmo de caminho mais

curto de Dijkstra de forma estática. Para utilização de um dos outros dois algoritmos, deve ser

inserida uma linha declarando o algoritmo a ser utilizado logo após a instanciação do

simulador. Isso é feito da forma apresentada na figura 23 para o Vetor de Distância. Para o

Estado de Enlace, é só informar LS no lugar de DV. Com isso, o simulador irá utilizar esses

algoritmos em todos os nós da rede.

Figura 23: Informação de utilização de Vetor de Distância no roteamento de pacotes na simulação da

rede.

As simulações foram realizadas num computador com as configurações descritas

na tabela 2.

Tabela 2: Configurações do computador onde foram feitas as simulações.

Processador Pentium Core 2 Duo CPU E5200, 2,50GHz (cada núcleo)

Memória 3,2GB

Sistema Operacional Ubuntu 9.0.4

Kernel 2.6.28-11-generic

51

Espaço em disco disponível 42,2GB

Swap 415,7MB

Para a análise da simulação, serão considerados os seguintes dados: a quantidade

de pacotes de dados enviados, a quantidade de pacotes de dados recebidos e a quantidade de

pacotes de roteamento. O ns-2 e o nam não fornecem esses dados de forma consolidada. Eles

apenas são registrados nos traces gerados com a execução dos scripts.

Para capturar esses dados, foi implementado um programa, escrito em Java, que

coletará os dados do trace e informará a quantidade de pacotes enviados pela origem do

tráfego e recebidos pelo destino do tráfego. Os métodos que retornam essas quantidades

recebem como argumentos os endereços de origem e destino e o tipo de tráfego a que

pertence os pacotes. Também foram criados métodos que retornam a quantidade de pacotes de

roteamento transmitidos durante toda a simulação pelo algoritmo de roteamento. O código

desse programa está disponível no apêndice III.

Na próxima seção são apresentados os resultados das simulações sobre os

diferentes cenários descritos.

4.1 Simulações e Resultados

Para a primeira rede utilizada nas simulações, estas foram inicialmente feitas com

a rede funcionando sem nenhum problema nos enlaces. Depois, foram realizadas simulações

onde três enlaces ficam indisponíveis por alguns segundos.

Quando não houve problemas com os enlaces da rede, foram obtidos os resultados

mostrados na tabela 3. A rede se comportou da mesma forma para os três algoritmos, como

esperado, enviando e recebendo a mesma quantidade de pacotes. Mas vê-se uma quantidade

muito superior de pacotes de roteamento de Vetor de Distância do que de Estado de Enlace.

Como o algoritmo de Dijkstra, aplicado de forma estática, não envia e nem recebe pacotes de

roteamento, sua sobrecarga de roteamento sobre a rede sempre será zero. Já em relação ao

tamanho dos pacotes de roteamento, os pacotes de Estado de Enlace apresentam tamanhos de

20B e, na maioria, 100B; já os pacotes de Vetor de Distância apresentam tamanhos de 12B.

Assim, teve-se uma sobrecarga maior na rede do algoritmo de Estado de Enlace do que do

52

Vetor de Distância. Nessa primeira etapa de simulações, foram geradas nos arquivos de trace

do ns-2, em média, 824.312 linhas.

Tabela 3: Resultados da simulação dos algoritmos de roteamento sobre a rede da figura 21

Dijkstra Estado de Enlace Vetor de Distância

Pacotes Enviados 47711 47711 47709

Pacotes Recebidos 47711 47711 47709

Pacotes de Roteamento - 456 1064

A tabela 4 mostra os resultados obtidos nas simulações quando há perda de três

enlaces na rede por alguns segundos. Desta vez, há diferença nos resultados de cada

algoritmo. A execução do algoritmo de Dijkstra, como esperado, fez com que muitos pacotes

enviados pelas fontes não chegassem ao destino. Já os algoritmos de Estado de Enlace e de

Vetor de Distância continuam com resultados parecidos e com pacotes de roteamento de

Vetor de Distância superior ao de Estado de Enlace, mas com uma proporção menor que a

simulação anterior. Assim, a sobrecarga de roteamento do algoritmo de Estado de Enlace

tornou-se ainda maior. Foram geradas, em média, 747.642 linhas nos arquivos de trace dessa

segunda etapa de simulações.

Tabela 4: Resultados da simulação dos algoritmos de roteamento sobre a rede da figura 21 onde três

enlaces ficam indisponíveis





Para entender os resultados obtidos, as figuras 25, 26 e 27 mostram as execuções

dos algoritmos, ilustrando os principais pontos de cada simulação. Nessas simulações os

instantes em que os enlaces (2, 3), (9, 8) e (4, 5) ficam indisponíveis são 10, 20 e 25

segundos, respectivamente. Os instantes da volta a estar disponíveis para o tráfego são 30, 35

e 40 segundos para os enlaces (9, 8), (2, 3) e (4, 5), nessa ordem. Nessas figuras, os pacotes na

cor azul correspondem ao tráfego entre os nós 0 e 4; em vermelho ao tráfego entre os nós 2 e

11; em verde o tráfego entre os nós 5 e 9; e em preto o tráfego entre os nós 6 e 1.

53

Figura 24: Simulação com o algoritmo de Dijkstra com perda de três enlaces na rede de topologia baseada

na rede Abilene.

A figura 24 exibe as capturas de vários momentos da execução do algoritmo de

Dijkstra nessa rede. Em (a) têm-se o estado do roteamento com todos os tráfegos sendo

roteados pelo caminho mais curto. A primeira perda de um enlace na rede pode ser visto em

(b). Vários pacotes que utilizavam o enlace (2, 3) são perdidos, como acontece no terceiro

54

enlace perdido, o (4, 5), mostrado em (e). Nenhum problema ocorreu com a perda do enlace

(9, 8), em (d), nessa simulação, pois não havia tráfego por ele.

Como esperado, após a perda do primeiro e terceiro enlaces, visto em (c) e (f), não

houve nenhuma alteração nas rotas. Os tráfegos gerados pelos agentes TCP param de ser

enviados, mas os enviados pelos agentes UDP continuam, os quais não vão chegar ao destino.

As capturas (g), (h) e (j) mostram o momento em que esses enlaces voltam a ficar disponíveis.

O primeiro enlace a voltar foi o (9, 8), não alterando em nada o tráfego, mas, com a volta dos

outros enlaces, os tráfegos anteriores à perda voltam a percorrer o caminho original, exceto do

tráfego que ia do nó 5 ao 9, que era gerada por uma aplicação FTP. Esta aplicação “desistiu”

de enviar pacotes.

Situações diferentes ocorreram com as simulações dos outros dois algoritmos.

Eles permitiram que continuassem a haver tráfego de pacotes entre os sistemas finais mesmo

com a perda dos enlaces, pois são dinâmicos. A figura 26 mostra vários momentos da

simulação do algoritmo de Estado de Enlace.

A primeira captura da simulação da figura 26 vista em (a), mostra o momento em

que vários pacotes de roteamento de Estado de Enlace, necessários para reconhecimento dos

custos de todos os enlaces e da topologia da rede (ver seção 2.5), são enviados antes do

tráfego dos pacotes em (b).

Quando ocorre a primeira perda de enlace, em (c), vários pacotes são perdidos,

mas a rota de tráfego é alterada logo que se percebe a indisponibilidade do enlace. Em (d) vê-

se que as rotas dos tráfegos entre os nós 0 e 4, 1 e 11 e, 6 e 1, começam a ser alteradas. Em (e)

vê-se a estabilização dessa alteração, mantendo a característica de caminho de menor custo.

55

Figura 25: Simulação do algoritmo de Estado de Enlace com perda de três enlaces na rede.

56

Com a perda do enlace (9, 8) em (f), nota-se, nas duas capturas seguintes, uma

particularidade na alteração das rotas pelo algoritmo de estado de enlace. Assim que houve a

perda do enlace, o tráfego entres os nós 6 e 1 começou a ser roteado pelo caminho 6, 7, 8, 4,

3, 9, 10, 1. Esse ainda não era o caminho mais curto. Após todos os enlaces terem uma visão

global da nova situação da rede, o caminho correto (6, 5, 4, 3, 9, 10, 1) passa a ser usado,

como pode ser visto em (g) e (h), onde o roteamento está estabilizado. Características

semelhantes vão ocorrer com a perda do terceiro enlace em (i).

A partir de (k) os enlaces voltam a ficar disponíveis e novas rotas são calculadas

pelo algoritmo de estado de enlace com a melhora no custo dos caminhos. Eles voltam em (k),

(m) e (o). Após isso, em (p), as rotas passam a ser as mesmas do roteamento original.

A figura 27 fornece vários momentos da simulação com o algoritmo de vetor de

distância. Como aconteceu com o algoritmo de estado de enlace, antes do tráfego de pacotes

de dados entre os nós, cada nó enviou pacotes de roteamento para conhecimento do custo dos

enlaces na rede. Como visto na seção 2.4, cada nó altera sua tabela de repasse de acordo com

as informações de custos obtidas por seus vizinhos e envia a eles as informações de custos

calculados localmente, se forem alterados em sua tabela.

Após essa troca de informações, o roteamento passa a ocorrer pelo caminho de

menor custo, como visto em (b). Nota-se que dois tráfegos estão ocorrendo por rotas

diferentes da calculada nas simulações anteriores. Na primeira, o tráfego entre os nós 0 e 4

está sendo feita no caminho 0, 10, 9, 3, 4 e, na segunda, o tráfego entre os nós 2 e 11 está

sendo feita pelo caminho 2, 3, 9, 8, 11. Nas outras simulações ocorriam, respectivamente,

pelos caminhos 0, 1, 2, 3, 4 e 2, 3, 4, 8, 11. Isso acontece porque existem duas rotas possíveis

de menor custo entre os nós 0 e 4 (custos de 4 saltos) e entre os nós 2 e 11 (custos de 4 saltos).

Assim, percebe-se que os diferentes algoritmos podem escolher uma dentre várias rotas

possíveis utilizando regras diferentes, que podem ser a primeira encontrada, a última

encontrada, a com menor identificador, dentre outras. (GARCIA et. al., 2007).

57

Figura 26: Simulação com o algoritmo de Vetor de Distância com perda de três enlaces na rede.

58

A primeira perda de enlace é vista em (c). Como aconteceram com as outras

simulações, vários pacotes são perdidos. Os nós começam a trocar informações para alterar

suas rotas. Vê-se que o nó 3 já passou a mandar pacotes com destino ao nó 1 pelo nó 9, pois

percebeu logo a perda do enlace. Em (d) pode ser visto o início da alteração da rota do tráfego

entre os nós 6 e 1. O roteamento passa a se estabilizar em (e).

Com a perda do enlace (9, 8), visto em (f), o nó 8 rapidamente envia os pacotes

com destino ao nó 1 pelo nó 4. Da mesma forma o nó 9 começa a enviar pacotes com destino

ao nó 11 pelo nó 3. Essa alteração possibilita que os pacotes, que ainda não foram para a fila

de saída com caminho pelo enlace indisponível, sejam redirecionados assim que se percebe a

alteração no custo dos enlaces. Em (g) percebe-se que houve uma demora na alteração para o

caminho correto de tráfegos entre os nós 2 e 11, pois o nó 1 passou a rotear alguns pacotes

pelo nó 0. Em (h) há a estabilização do roteamento. Características semelhantes acontecem

com a quebra do terceiro enlace em (i).

A partir da captura (k) ocorre a volta dos enlaces. Em (n) nota-se um ponto

importante: mesmo com a volta do enlaces (2, 3), o tráfego não voltou a ocorrer pelo caminho

original, mas por outro caminho que também tem o menor custo. A mesma coisa aconteceu

com o tráfego do nó 6 ao nó 1 em (o). Em (p) têm-se o resultado final das alterações no

tráfego.

Depois de feita simulações sobre a rede da figura 21, foram realizadas as

simulações sobre a rede mostrada na figura 22.

Inicialmente foram feitas simulações sem mudança nos custos dos enlaces, ou

seja, com todos os enlaces disponíveis. Com essa primeira etapa de simulações na segunda

rede, foi obtido o resultado mostrado na tabela 5. Como esperado, as quantidades de pacotes

enviadas e recebidas foram as mesmas para os três algoritmos. Nenhum pacote foi descartado.

Mas, quando verifica-se a sobrecarga de roteamento sobre a rede, nota-se que o algoritmo de

Estado de Enlace possui uma sobrecarga menor, em termos de quantidade, do que o algoritmo

de Vetor de Distância. Foram geradas, em média, 241.886 linhas nos arquivos de traces do

ns-2 nessas simulações.

59

Tabela 5: Resultado da simulação sobre a rede da figura 22, sem alteração nos enlaces





Num outro cenário, em que há a perda do enlace (3, 4) da mesma rede, notam-se

algumas modificações nos resultados. Como mostra a tabela 6, quando usado o algoritmo de

Dijkstra a quantidade de pacotes enviados foi inferior do que quando aplicado os algoritmos

de Vetor de Distância e Estado de Enlace, devido ao mecanismo de controle de fluxo aplicado

quando o protocolo utilizado na camada de transporte é o TCP. Muitos pacotes não foram

recebidos no destino quando aplicado o algoritmo de Dijkstra. Estado de Enlace e Vetor de

Distância continuam com dados parecidos, exceto na quantidade de pacotes de roteamento.

Nessas simulações, foram geradas, em média, 218.274 linhas nos traces.

Tabela 6: Resultado da segunda simulação, onde o enlace (3, 4) fica indisponível.





Para o terceiro cenário, onde a quantidade de tráfego aumenta de 2 para 6, foram

obtidos os resultados mostrados na tabela 7.

Tabela 7: Resultado de simulação sobre a rede da figura 22 com 6 tráfegos





Nota-se que os resultados entre os algoritmos de Estado de Enlace e Vetor de

Distância continuam parecidos, com uma pequena vantagem para o algoritmo de Vetor de

Distância. A aplicação do algoritmo de Dijkstra continua a diminuir bastante o tráfego na

rede. Nessas simulações foram geradas nos traces, em média, 486.119 linhas.

60

Após essas simulações, foram feitas outras simulações buscando verificar o

comportamento dos algoritmos com os problemas de oscilação, loops e contagem ao infinito.

Essas simulações foram feitas de acordo com os cenários específicos apresentados na seção

3.2 para a primeira rede.

Para verificação de oscilação, os enlaces (3, 4) e (9, 8) ficaram alternadamente

indisponíveis durante 40 segundos. Nesse cenário as execuções dos algoritmos de Estado de

Enlace e Vetor de Distância fizeram com que o roteamento de pacotes ficasse oscilando entre

os enlaces que ficavam disponíveis. Pela tabela 8, nota-se que as quantidades de pacotes

enviados e recebidos, com a execução desses algoritmos, foram reduzidas em relação ao

resultado do cenário com perda de três enlaces sem oscilação mostrado na tabela 4, mas sem

muita diferença entre um algoritmo e outro. Por outro lado, a sobrecarga de roteamento do

Estado de Enlace passou a ser muito maior que a do Vetor de Distância.

Tabela 8: Resultado da simulação sobre a rede 1 com oscilação no roteamento. Dijkstra Estado de Enlace Vetor de Distância




Para verificação de ocorrências de loops e contagem ao infinito foram

acrescentados mais três tráfegos e isolados os nós 0, 1 e 10 dos demais nós da rede. Nessa

simulação, o algoritmo de Estado de Enlace verificou rapidamente que não havia mais um

caminho até os nós 0, 1 e 10 e não houve mais tráfego para esses nós ou que originaram deles

enquanto ficaram indisponíveis. Já com a execução do Vetor de Distância houve ocorrência

de loops e contagem ao infinito durante toda a simulação para tráfegos gerados por agentes

UDP e sobre o TCP. Como exemplo, o tráfego entre os nós 6 e 10 ficou sendo repassado do

nó 7 ao 8 e do nó 8 ao 7 durante todo o período em que os enlaces (10, 9) e (1, 2) ficaram

indisponíveis. Como pode-se ver na tabela 9, quase a metade dos pacotes que foram enviados,

com a execução do Vetor de Distância, não chegaram ao destino. Além disso, a sobrecarga de

roteamento do Vetor de Distância passou a ser maior do que a do Estado de Enlace.

61

Tabela 9: Resultado da simulação com a perda dos enlaces (10, 9) e (1, 2) na rede 1 para verificação de formação de loops e contagem ao infinito.





4.2 Análise dos Resultados Computacionais

Diante dos resultados obtidos na seção anterior, nota-se que os algoritmos de

Dijkstra, Estado de Enlace e Vetor de Distância sempre fornecem, como esperado, o caminho

de menor custo para os tráfegos da rede. Cada simulação, executada com diferentes

algoritmos, teve características distintas na forma de obtenção de caminhos, escolha das rotas

e percepção da mudança do custo dos enlaces.

Nas simulações, quando a rede não sofre nenhuma alteração nos enlaces, todos os

algoritmos funcionaram praticamente da mesma forma, obtendo resultados iguais ou muito

próximos na transmissão e recepção de pacotes de dados entre fontes e destinos,

respectivamente.

Começaram a ocorrer diferenças quando os enlaces das redes sofreram alterações

durante a execução da simulação. Nota-se que sempre o algoritmo de Dijkstra, aplicado de

forma estática, obteve resultados piores que os algoritmos dinâmicos quando houveram

alterações nas topologias das redes. Nas tabelas 4, 6 e 7 percebeu-se que a quantidade de

pacotes enviados foi muito inferior para o algoritmo de Dijkstra do que para os outros

algoritmos. Além disso, a proporção de pacotes que não chegaram ao destino também superou

a dos outros.

O roteamento estático não pode ser utilizado em redes que tem muitas alterações

no custo de seus enlaces devido a grande perda de pacotes. Dentre os algoritmos estáticos

apresentados, o algoritmo de Dijkstra tem complexidade menor do que o algoritmo de Floyd-

Warshall. Como visto, algoritmo de Dijkstra é utilizado no algoritmo de Estado de Enlace

para obtenção dos caminhos de menor custo.

62

As simulações dos algoritmos dinâmicos de Estado de Enlace e de Vetor de

Distância mostraram que seus resultados são muito próximos um do outro. A maior diferença

está por conta da sobrecarga de roteamento. O algoritmo de Vetor de Distância envia mais

pacotes para a rede para poder convergir corretamente do que o algoritmo de Estado de

Enlace. Porém, o tamanho dos pacotes de Estado de Enlace gerado nas simulações são

maiores que os do Vetor de Distância. O primeiro gerou pacotes de 20B e 100B, enquanto o

segundo gerou pacotes de apenas 6B e 12B. Dependendo da diferença da quantidade de

pacotes enviadas, o Vetor de Distância pode impor um sobrecarga menor sobre a rede que o

Estado de Enlace.

Como apresentado na seção 2.4, o algoritmo de Vetor de Distância pode convergir

lentamente e tem o problema da contagem ao infinito. Mas, segundo KUROSE e ROSS,

2006, p. 287, os algoritmos de Estado de Enlace e Vetor de Distância são muito utilizados e,

na prática, nenhum deles é melhor do que o outro.

Na primeira simulação nota-se que vários caminhos tinham o mesmo custo. Isso

poderia ser aproveitado para balancear o tráfego e evitar que eles se concentrassem em apenas

poucos enlaces, como ocorreu, por exemplo, no instante mostrado na figura 25(b), onde os

quatro tráfegos estavam passando pelo enlace (3, 4). Para conseguir esse balanceamento nessa

rede, pode-se usar o algoritmo Estendido de Dijkstra no Estado de Enlace, já que nota-se

formação de alguns anéis na rede quando há tráfego de pacotes entre os nós 1 e 6, 3 e 10, 2 e

9, 4 e 9 e, 3 e 8. Mas isso é apenas para o caso específico de formação de anéis na rede. Em

casos gerais esse benefício pode não acontecer.

De maneira geral, para redes que possuem muitas alterações na topologia, a

utilização de algoritmos dinâmicos é a melhor maneira de rotear pacotes em redes de

computadores unicast para garantir um grande número de entrega de pacotes.

63

5 CONCLUSÃO

Como visto neste trabalho, existem muitos algoritmos de roteamento propostos

com diferentes características e objetivos. Muitos desses algoritmos procuram reagir à

mudança de custos na rede, fornecer qualidade de serviço, “otimizar” a entrega de pacotes ou

apenas calculam o roteamento no início do tráfego de pacotes baseado no menor custo. Há

também bastante interesse no estudo do roteamento em MANETs e QoS.

O roteamento em redes de computadores unicast é o mais tradicional, tendo o

algoritmo de Estado de Enlace e o algoritmo de Vetor de Distância como predominantes nesse

tipo de rede. Propostas de outros algoritmos que buscam garantir balanceamento de carga,

como o algoritmo Estendido de Dijkstra, vão surgindo como sugestão para serem

incorporados no roteamento de rede.

Quando há muita alteração na topologia das redes de computadores, algoritmos de

roteamento estático não oferecem bons resultados, sendo mais aceitável a utilização de

algoritmos dinâmicos. As simulações apresentadas nesse trabalho comprovaram essas

características, principalmente quando o tráfego na rede aumenta e muitos enlaces ficam

indisponíveis.

As simulações mostraram que os algoritmos dinâmicos de Estado de Enlace e de

Vetor de Distância produzem resultados parecidos na entrega de pacotes de dados. Eles são

muito utilizados na prática em muitos protocolos de roteamento, dentre eles o OSPF e o RIP.

64

5.1 Contribuições e Trabalhos Futuros

Uma contribuição deste trabalho é a sua utilidade nas disciplinas de Redes de

Computadores e Grafos, pois fornece simulações dos principais algoritmos de roteamento

usados atualmente e que são baseados em algoritmos de grafos, além de fornecer cenários já

prontos para simulação, orientação na utilização do simulador e discussão detalhada da

execução dos algoritmos.

Existem alguns trabalhos que simulam alguns algoritmos MANETs híbridos e que

trazem comparações com protocolos reativos e proativos. DUKTA, 2008, implementa o

protocolo VRP no ns-2 e faz algumas comparações com protocolos DSR.

WOJCIECHOWSKI, 2008, por sua vez, implementa o protocolo ZRP no ns-2 e compara-o

com os protocolos DSR e DSDV.

Futuramente podem ser feitas simulações com algoritmos que suportam

parâmetros de QoS. Podem ser analisados vários tipos de combinações de parâmetros a fim de

dar um bom entendimento de seu funcionamento para diferentes tipos de cenários e objetivos.

Também podem ser analisados algoritmos utilizados em rede de computadores multicast e

descrever suas utilidades para as redes modernas.

Outra possibilidade é implementar o algoritmo Estendido de Dijkstra no ns-2,

utilizá-lo no algoritmo de Estado de Enlace e comparar os resultados das simulações dessa

nova implementação com o algoritmo já implementado no simulador.

65

APÊNDICE

Apêndice I – Script de simulação da rede baseada na Rede Abilene

Apêndice II – Script de simulação de uma rede com 6 nós

Apêndice III – Código em Java de programa para coleta de dados de traces gerados pelo ns-2

66

I – Script de simulação da rede baseada na Rede Abilene.

69

II – Script de simulação de uma rede com 6 nós

71

III – Código em Java de programa para coleta de dados de traces gerados pelo ns-2

74

REFERÊNCIAS BIBLIOGRÁFICAS

1. BOPPANA, Rajendra V.; KONDURU, Satyadeva P. An Adaptive Distance Vector

Routing Algorithm for Mobile, Ad Hoc Networks. INFOCON, 2001. Disponível

em: <http://ieeexplore.ieee.org/iel5/ 7321/19795/00916673.pdf>. Acesso em:

18/06/2008.

2. BURIOL, Luciana Salete. Roteamento do Tráfego na Internet: Algoritmos para

Projeto e Operação de Redes com Protocolo OSPF. 2003. Tese (Doutorado em

Engenharia Elétrica) – Faculdade de Engenharia Elétrica e Computação da

Universidade Estadual de Campinas, Campinas, 2003. Disponível em:

<http://libdigi.unicamp.br/document/? code=vtls000313913>. Acesso em: 18/06/2008.

3. CÂMARA, Daniel. Estudo Sobre Algoritmos de Roteamento para Redes Móveis

Ad hoc. 2000. Dissertação (Mestrado em Ciência da Computação) – Departamento de

Ciência da Computação da Universidade Federal de Minas Gerais, Belo Horizonte,

2000. Disponível em: <http://www.eurecom.fr/~camara/dissertacao/>. Acesso em:

18/06/2008.

4. CORMEN, Thomas H.; LEISERSON, Charles E.; RIVEST, Ronald L.; STEIN,

Clifford. Algoritmos: teoria e prática. 2. ed. Rio de Janeiro: Elsevier, 2002.

5. COSTA, Luís Henrique M. K.; AMORIM, Marcelo D.; FDIDA, Serge. Reduzindo a

Freqüência de Inundações em Protocolos de Roteamento Ad Hoc Sob Demanda.

2003. Disponível em: <http://en.scientificcommons.org/6842750>. Acesso em:

18/06/2008.

75

6. DODGE, Martin. An Atlas Of Cyberspaces, 2004. Disponível em:

<http://personalpages.manchester.ac.uk/staff/m.dodge/cybergeography/atlas/more_isp

_maps.html>. Acesso em: 07/06/2009.

7. DUKTA, Protocolo de Roteamento Híbrido Para Redes Ad Hoc Móveis:

Desenvolvimento de Protocolo VRP no Network Simulator 2. Sociedade Educacional

de Santa Catarina – Instituto Superior Tupy, Joinville, 2008. Disponível em: <

http://ist.sociesc.com.br/cursos/bsi/TrabalhoDeDiplomacao/TD-EduardoDutka-2008-

2.pdf>. Acesso em: 19/06/2009.

8. GARBE, Bruno Jr. Análise de Algoritmos de Roteamento Baseado em Formigas.

2006. Dissertação (Mestrado) – Escola Politécnica da Universidade de São Paulo.

Departamento de Engenharia de Telecomunicações e Controle, São Paulo, 2006.

Disponível em: <http://www.teses.usp.br/teses/disponiveis/3/3139/tde-13122006-

181657/>. Acesso em: 18/06/2008.

9. GARCIA, Nuno M.; LENKIEWICZ, Przemyslaw, FREIRE, Mário M.; Monteiro,

Paulo P. On the Performance of Shortest Path Routing Algorithms for Modeling

and Simulation of Static Source Routed Networks – an Extension to the Dijkstra

Algorithm. IEEE Second International Conference on Systems and Networks

Communications, 2007. Disponível em: <http://ieeexplore.ieee.org/Xplore/login.jsp?

url=/iel5/4299965/4299966/04300032.pdf?temp=x>. Acesso em 14/03/2008.

10. GREIS, Marc. Tutorial for the Network Simulator “ns”, 2000. Disponível em:

<http://www.isi.edu/nsnam/ns/tutorial/index.html>. Acesso em 16/04/2009.

11. FALL, Kevin; VARADHAN, Kannan. The ns Manual (formerly ns Notes and

Documentation), 2009. Disponível em <http://www.isi.edu/nsnam/ns/ns-

documentation.html>. Acesso em 09/04/2009.

12. KOUNDINYA K, A.; NEGI, Atul; SASTRY, V. N. Unicast Routing with Multiple

Quality-of-Service Parameters. IEEE Proceedings 7th International Symposium on

Parallel Architectures, Algorithms and Networks, 2004. Disponível em:

76

<http://ieeexplore.ieee.org/Xplore/login.jsp?url=/iel5/9103/28881/01300531.pdf?arnu

mber=1300531>. Acesso em 04/04/2008.

13. KUROSE, J. F; ROSS, K. W. Redes de computadores e a internet: uma abordagem

top-down. 3. ed. São Paulo: Addison-Wesley, 2006.

14. LIU, Wei; LOU, Wenjing; FANG, Yuguang. A Selection Function Based Distributed

Algorithm for Delay-Constraint Least-Cost Unicast Routing. IEEE International

Conference, v. 3, p. 1738-1742, 2003. Disponível em:

<http://ieeexplore.ieee.org/Xplore/login.jsp?url=/iel5/8564/27115/01203898.pdf?arnu

mber=1203898 >. Acesso em: 18/06/2008.

15. LORENZ, Dean H.; ORDA, Ariel; RAZ, Danny; SHAVITT, Yuval. Efficient QoS

partition and routing of unicast and multicast. IEEE/ACM Transactions on

Networking (TON), v. 14, p. 1336-1347, 2006. Disponível em:

<http://portal.acm.org/citation.cfm?id=1217687.1217703& coll=portal&dl=ACM>.

Acesso em: 18/06/2008.

16. MOHSENI, Maryan; VAHEDI, Shabnam; NADERI, Majid. A New Position-Based

Routing Algorithm for the Reduction of Overhead in Ad-hoc Networks. IEEE

Second International Conference on Systems and Networks Communications, 2007.

Disponível em:

<http://ieeexplore.ieee.org/Xplore/login.jsp?url=/iel5/4299965/4299966/04299979.pdf

?temp=x>. Acesso em 14/03/2008.

17. SEGUÍ, Carles; ZABALLOS, Augustín; CADENAS, Xavier; SELGA, Josep M.

Evolution of unicast routing protocols in data networks. IEEE The 25th Conference

on Computer Communications, 2006. Disponível em <http://www.ieee-

infocom.org/2006/postersandemos.htm>. Acesso em: 14/03/2008.

18. TANEMBAUM, A. S. Redes de Computadores. 4. ed. São Paulo: Campus, 2003.

19. The Network Simulator - ns-2, 2009. Disponível em:

<http://www.isi.edu/nsnam/ns/>. Acesso em 10/04/2009.

77

20. WOJCIECHOWSKI, Ricardo. Protocolo de Roteamento Híbrido ZRP: Estudo,

Implementação no ns-2 e Comparativo do Seu Desemplenho. Sociedade Educacional

de Santa Catarina – Instituto Superior Tupy, Joinville, 2008. Disponível em: <http://

ist.sociesc.com.br/cursos/bsi/TrabalhoDeDiplomacao/TD-RicardoWojciechowski-

2008-2.pdf>. Acesso em: 19/ 06/2009.

SIMULAÇÃO DE ALGORITMOS DE ROTEAMENTO UNICAST … · algoritmos de roteamento, as propriedades...

Documents

Transcript of SIMULAÇÃO DE ALGORITMOS DE ROTEAMENTO UNICAST … · algoritmos de roteamento, as propriedades...