Algoritmos de redes

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.
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.

Algoritmos de redes

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (8)

Semelhante a Algoritmos de redes

Semelhante a Algoritmos de redes (20)

Algoritmos de redes