Projeto de Redes II

Prévia do material em texto

PROJETOS DE REDES I –
ANÁLISE DE DESEMPENHO DE 
REDE 
AULA 2 
 
 
 
 
 
 
 
 
 
 
Prof. Luis José Rohling 
 
 
 
 
2 
CONVERSA INICIAL 
Conforme vimos anteriormente, na etapa de projeto de redes, para o 
dimensionamento dos recursos de redes podermos empregar as ferramentas de 
simulação. Assim, nesses ambientes podermos criar a topologia projetada em 
um ambiente virtual, avaliando o desempenho das conexões que poderão, por 
exemplo, representar gargalos na rede, sendo que uma das principais 
ferramentas disponíveis é o NS-3. Temos também os simuladores que permitem 
testar e validar as configurações dos equipamentos, como o Packet Tracer, que 
também é amplamente utilizado para o processo de aprendizagem, sendo 
utilizado nas aulas práticas nos diversos cursos de redes. 
Para a elaboração de projetos com o NS-3, é necessária a construção dos 
projetos empregando uma linguagem de programação, que pode ser o C++ ou 
o Python, empregando as diversas bibliotecas das funcionalidades que serão 
utilizados no projeto de simulação. Dessa forma, para a criação desses projetos, 
é necessária a configuração de um ambiente de desenvolvimento, com a 
instalação das ferramentas próprias para essa construção dos projetos. E 
também serão necessárias as ferramentas que irão auxiliar no processo de 
análise do resultado da simulação, pois a saída da execução do projeto será um 
arquivo contendo os dados sobre o cenário simulado. 
Anteriormente, vimos como preparar esse ambiente para a execução dos 
projetos de simulação com o NS-3, para as plataformas baseadas nas 
distribuições Linux, bem como a instalação das ferramentas auxiliares, tal como 
o NetAnim, que permitirá a animação da execução do processo de simulação, 
com base no arquivo gerado, no modo chamado de offline, além de outras 
ferramentas. Nesta aula, daremos continuidade ao processo de instalação do 
NS-3 e da execução dos projetos de simulação de redes. 
TEMA 1 – INSTALAÇÃO DO NS3 
Após a preparação do ambiente, podemos realizar a instalação do NS-3, 
sendo que uma das formas de instalação é a utilização do Bake, que é uma 
ferramenta que permite instalar, construir e descobrir os requisitos ausentes no 
ambiente onde será instalado e executado o NS-3. Para que o Bake seja 
executado corretamente, é necessário que tenhamos a instalação do Python 
com a versão 2.7 ou posterior, bem como o Git, também instalado na máquina. 
 
 
3 
Portanto, primeiro, utilizando o Git, é necessário realizar o download do 
Bake e, em seguida, ir para o diretório onde se deseja realizar a sua instalação 
e executar o seguinte comando: 
git clone https://gitlab.com/nsnam/bake 
Também é recomendável adicionarmos o Bake ao caminho, com os 
comandos: 
export BAKE_HOME=`pwd`/bake 
export PATH=$PATH:$BAKE_HOME 
export PYTHONPATH=$PYTHONPATH:$BAKE_HOME 
Após a execução desses comandos, podemos utilizar o Bake para 
encontrar os pacotes que ainda faltam, realizar o download da compilação e 
fazer a instalação do NS-3 e dos seus módulos. 
Para descobrirmos os módulos que ainda podem estar faltando no 
sistema e que serão necessários para a correta instalação do NS-3, podemos 
utilizar a verificação com o bake check: 
bake.py check 
Com a execução desse comando, deveremos ter a seguinte saída do 
sistema: 
> Python - OK 
 > GNU C++ compiler - OK 
 > Mercurial - OK 
 > CVS - OK 
 > GIT - OK 
 > Bazaar - OK 
 > Tar tool - OK 
 > Unzip tool - OK 
 > Unrar tool - OK 
 > 7z data compression utility - OK 
 > XZ data compression utility - OK 
 > Make - OK 
 > cMake - OK 
 > patch tool - OK 
 > autoreconf tool - OK 
 
 
4 
 > Path searched for tools: /usr/lib64/qt-3.3/bin 
 /usr/lib64/ccache /usr/local/bin 
/usr/bin/bin/usr/local/sbin /usr/sbin /sbin 
/user/dcamara/home/scripts/user/dcamara/home/INRIA/Programs
/bin 
/user/dcamara/home/INRIA/repos/llvm/build/Debug+Asserts/bin 
Antes de realizar o download e a construção do NS-3, é necessário 
configurarmos o Bake para informá-lo de quais são os módulos que desejamos 
adicionar ao NS-3, tal como a distribuição padrão, por exemplo. Assim, 
poderemos utilizar o seguinte comando: 
bake.py configure -e ns-3.29 
Para verificar se os módulos necessários foram realmente adicionados, 
bem como os demais requisitos específicos do sistema para essa configuração, 
podemos então utilizar o bake show, com o comando: 
bake.py show 
Para realizar o download dos módulos, realizar a construção e a 
instalação, podemos então executar o recurso de deploy do Bake, executando o 
comando: 
bake.py deploy 
Com a execução desse comando, faremos o download dos módulos 
selecionados, bem como de todas as suas dependências, e será realizada a 
compilação do NS-3, incluindo todos estes módulos independentes. Porém, 
também podemos realizar esta instalação passo a passo, ou seja, realizando o 
download e compilação em duas etapas, com os comandos: 
bake.py download 
bake.py build 
 
 
 
5 
1.1 Download via Mercurial 
Saiba mais 
1. O código fonte do NS-3 está disponível nos repositórios Mercurial, onde 
poderá ser encontrada sempre a versão mais recente, por exemplo, a versão ns-
3.26. 
NSAM. NS-3 Network Simulator. Disponível em: 
<https://www.nsnam.org/>. Acesso em: 12 jul. 2021. 
2. Também é possível realizar o download do tarball da versão mais 
recente acessível no link a seguir: 
NS-3. Releases. Disponível em: <https://www.nsnam.org/releases/>. 
Acesso em: 12 jul. 2021. 
 Ou podemos trabalhar com os repositórios utilizando o Mercurial, porém, 
conforme vimos anteriormente, a recomendação é de que seja utilizado, 
preferencialmente, o Mercurial. 
A maneira mais simples para a utilização dos repositórios Mercurial é a 
utilização do ambiente ns-3-allinone, que é composto de um conjunto de scripts 
que realizam o gerenciamento do download e a construção de vários 
subsistemas do NS-3, sendo recomendável também que a primeira instalação, 
por novos usuários dessa ferramenta, seja realizada nesse ambiente. 
Para a realização do download do NS-3 utilizando o Git, devemos, 
inicialmente, criar um diretório chamado repos, no diretório home, onde 
devermos armazenar os repositórios locais do Git. E se utilizarmos essa 
abordagem, considerando que o Git já está instalado, poderemos então obter 
uma cópia de ns-3-allinone. Para preparar o ambiente e realizar o download, 
devermos digitar os seguintes comandos no shell no Linux: 
cd 
mkdir repos 
cd repos 
git clone https://gitlab.com/nsnam/ns-3-allinone.git 
Ao digitarmos o último comando de execução do Git, deveremos ter a 
exibição das mensagens abaixo: 
Cloning into 'ns-3-allinone'... 
remote: Enumerating objects: 232, done. 
 
 
6 
remote: Counting objects: 100% (232/232), done. 
remote: Compressing objects: 100% (121/121), done. 
remote: Total 232 (delta 135), reused 197 (delta 108) 
Receiving objects: 100% (232/232), 99.76 KiB | 513.00 KiB/s, done. 
Resolving deltas: 100% (135/135), done. 
1.2 Atualização da versão 
Após a execução do comando ser concluída, deveremos ter um diretório 
chamado ns-3-allinone dentro do diretório ~/repos, cujo conteúdo deve ser 
semelhante ao mostrado abaixo: 
build.py* constants.py dist.py* download.py* README util.py 
Conforme podemos observar na saída do comando, agora já temos os 
scripts do Python, porém ainda não temos o código do C++. Assim, o próximo 
passo será utilizar estes scripts para realizar o download e a construção da 
versão do NS-3 desejada. 
Saiba mais 
Se acessarmos a página do Git, temos uma série de repositórios 
disponíveis, sendo que muitos desses repositórios são de acesso restrito à 
equipe de desenvolvimento NS-3, porém os repositórios que possam ser de 
interesse geral estarão prefixados com ns-3, onde os lançamentos oficiais do 
NS-3 estão numerados utilizando a seguinte notação ns-3.release.hotfix. Por 
exemplo, para uma versão do NS-3, aindahipotética, igual à nove, estando na 
sua segunda revisão (hotfix), seria identificada como a versão ns-3.9.2 na página 
do repositório. 
GITLAB.COM. Disponível em: <https://bit.ly/3yQEthU>. Acesso em: 12 jul. 
2021. 
A imagem da versão de desenvolvimento do NS-3 mais atual, que ainda 
não foi lançada, pode ser encontrada acessando o link a seguir: 
GITLAB. ns-3-dev. Gittlab, S.d. Disponível em: 
<https://gitlab.com/nsnam/ns-3-dev/>. Acesso em: 12 jul. 2021. 
Nesses repositórios teremos então as versões do NS-3 que os 
desenvolvedores tentam manter em estado operacional consistente, porém, 
como estão em uma área de desenvolvimento, deve ser preferível utilizarmos os 
 
 
7 
lançamentos oficiais, caso não seja necessária a utilização de algum recurso que 
tenha sido desenvolvido mais recentemente e que ainda não esteja incorporado 
à última versão oficial. E para encontrarmos a versão mais recente do código do 
NS-3, podemos realizar uma inspeção da lista de repositórios ou acessando a 
página da web Getting Started e procurando o identificador de versão mais 
recente. 
Para realizar o download da versão mais recente, considerando que esta 
versão é a ns-3.30, devermos digitar no shell do Linux o comando: 
/download.py -n ns-3.30 
Outra opção para esse comando é a substituição da versão ilustrada 
acima por outra versão desejada. Caso seja omitida a versão, será realizado o 
download da versão indicada como referência no ns-3-dev. 
Após a realização do processo de download, deveremos ter diversos 
novos diretórios sob o diretório ~/repos/ns-3-allinone, conforme mostrado a 
seguir: 
bake constants.py download.py ns-3.30 __pycache__ util.py 
build.py dist.py netanim pybindgen README 
Após o processo de download e criação dos diretórios mostrados acima, 
se entrarmos no diretório ns-3.30, criado no diretório ~/repos/ns-3-allinone, 
poderemos identificar que teremos neste diretório o seguinte conteúdo: 
AUTHORS CONTRIBUTING.md Makefile src utils.py 
waf-tools bindings doc README.md test.py VERSION 
wscript CHANGES.html examples RELEASE_NOTES testpy.supp 
waf ils.py contrib LICENSE scratch 
utils waf.bat 
Assim, realizado o download e verificada a existência de todos os 
componentes necessários, agora poderemos realizar a construção do NS-3, que 
também é chamada de compilação, já que se trata da montagem de um 
executável com base em um código fonte, nas suas bibliotecas e nos demais 
componentes. 
1.3 Download via tarball 
Outra opção para a realização do download do NS-3 é a utilização do 
tarball, sendo que este processo de download, via tarball, é mais simples do que 
 
 
8 
o processo Mercurial, já que todos os componentes já estão agrupados, sendo 
apenas necessária escolher a versão desejada, realizando o download e a 
descompactação do mesmo. 
Da mesma forma como mencionado anteriormente, é recomendável a 
criação de um diretório nomeado como repos, no diretório home, onde serão 
armazenados os repositórios Mercurial localmente, podendo-se também utilizar 
um diretório nomeado como tarballs. Se criarmos o diretório tarbialls, poderemos 
então obter uma cópia da versão do NS-3 desejada, digitando-se o número da 
versão e da revisão conforme visto anteriormente, utilizando o seguinte comando 
no shell do Linux: 
cd 
mkdir tarballs 
cd tarballs 
wget http://www.nsnam.org/release/ns-allinone-3.30.tar.bz2 tar 
xjf ns-allinone-3.30.tar.bz2 
Após a execução do comando anterior, ao acessarmos o diretório criado, 
que é o ns-allinone-3.30, teremos os seguintes arquivos: 
bake constants.py ns-3.30 README 
build.py netanim-3.108 pybindgen-0.20.0 util.py 
Assim, tendo utilizado o tarball para a realização do download, agora 
também poderemos realizar a construção/compilação do NS-3. 
TEMA 2 – CONSTRUÇÃO DO NS3 
Quando construirmos um projeto com o NS-3 pela primeira vez, é 
recomendável a utilização do ambiente allinone, que irá configurar o projeto de 
uma maneira muito mais prática e eficiente. 
Para a construção/compilação do NS-3, deveremos então entrar no 
diretório que foi criado para a realização do download. Dessa forma, tendo sido 
realizado o download utilizando o Mercurial, teremos um diretório chamado ns-
3-allinone, que está localizado no diretório ~/repos. Se foi realizado o download 
utilizando o tarball, teremos um diretório identificado como ns-allinone-3.13, 
dentro do diretório ~/tarballs. Assim, estando no diretório correto, deveremos 
então executar o comando: 
/build.py 
 
 
9 
Ao executarmos esse comando, deverão ser mostradas muitas 
mensagens típicas de saída do compilador, que serão exibidas à medida que o 
script de compilação constrói os vários componentes que foram baixados. Assim, 
deveremos visualizar as seguintes mensagens: 
Build finished successfully (00:02:37) 
Leaving directory `./ns-3-dev' 
Terminado o processo de montagem do projeto, normalmente não 
utilizaremos mais os scripts ns-3-allinone, pois a partir deste ponto iremos 
interagir diretamente com o WAF, o que será realizado no diretório ns-3-dev e 
não mais no diretório ns-3-allinone. 
Portanto, após a montagem do NS-3, poderemos então utilizar o WAF 
para a elaboração dos projetos. E uma das primeiras ações a ser realizada, para 
nos familiarizarmos com o WAF, é a verificação de quais são as opções de 
configuração válidas, para a utilização do WAF. Para isso, podemos utilizar o 
recurso de ajuda do WAF, utilizando o comando: 
./waf -–help 
2.1 Depuração via WAF 
Uma das opções mais importantes do WAF é o comando de debug, que 
será empregado para realizarmos a depuração do processo de execução dos 
projetos, cuja sintaxe é: 
-d <debug level=""> 
Os níveis de depuração que poderão ser utilizados, e que podem ser 
verificados por meio do comando “waf --help”, são os níveis de debug ou 
optimized. 
Também é possível alterarmos os flags utilizados para o processo de 
compilação, tal como mostrado no exemplo abaixo: 
CXXFLAGS="-O3" ./waf configure 
E caso estejamos utilizando o compilador gcc, o comando para a 
configuração dos flags será: 
CXX=g++-3.4 ./waf configure 
 
 
10 
Devemos observar ainda que, de modo diferente de algumas outras 
ferramentas de compilação, para alterarmos o objeto da compilação, a opção 
deve ser fornecida durante a fase de configuração, e não na etapa de 
compilação. Desta forma, o comando “./waf -d optimized” não funcionará, 
devendo ser utilizado o comando: 
./waf -d optimized configure 
E os arquivos binários, resultantes do processo de depuração, serão 
armazenados no diretório build/<debuglevel>/srcpath. Por exemplo, após a 
depuração de uma compilação, encontraremos o executável para o exemplo 
first.cc no diretório build/examples/first. 
Podemos também realizar a depuração do executável diretamente com 
os comandos: 
./waf --shell 
cd build/debug/examples 
gdb ns-<version>-first-debug 
Além deste exemplo, podermos também executar gdb em emacs, ou 
utilizarmos outro depurador, tal como o ddd ou o insight. Em uma compilação 
otimizada, podemos encontrar o executável para o exemplo first.cc tendo sido 
salvo como “build/examples/ns-<version>-first-optimized”. 
2.2 Outras opções do WAF 
Outra opção, que eventualmente pode ser necessária, é a desativação 
das ligações Python. Assim, para forçarmos a desativação dessas ligações, 
poderemos utilizar a seguinte opção: 
./waf --disable-python configure 
E para ajustarmos o sistema de compilação, de modo que seja utilizado o 
programa sudo para definir o bit suid, se for necessário, poderemos então utilizar 
a seguinte configuração: 
./waf --enable-sudo configure 
Quando for necessário iniciarmos uma configuração do zero, ou seja, 
realizando a remoção de todas as configurações anteriores, deveremos utilizar 
o comando: 
 
 
11 
./waf distclean 
Casoocorra algum problema, e as demais soluções falharem, poderemos 
então utilizar o comando: 
rm -rf build 
E este comando deverá ser seguido pela opção de retorno para o ns-3-
allinone e execução do comando: 
./build.py 
Assim, estaremos realizando, basicamente, o reset do estado de 
construção. 
2.3 Validação da instalação 
O simulador ns-3 possui testes de unidade que podem ser executados 
para verificar a instalação. Assim, para executarmos esse teste, o comando a 
ser utilizado é: 
./test.py 
Após a execução deste comando, deveremos ter como resultados as 
mensagens vistas abaixo: 
PASS: TestSuite histogram 
PASS: TestSuite ns3-wifi-interference 
PASS: TestSuite ns3-tcp-cwnd 
PASS: TestSuite ns3-tcp-interoperability 
PASS: TestSuite sample 
... 
TEMA 3 – EXECUÇÃO DOS SCRIPTS 
A execução dos scripts do NS-3 normalmente é realizada utilizando o Waf, 
pois isso permite que o sistema de compilação garanta que os caminhos da 
biblioteca compartilhada estejam definidos corretamente, e que as bibliotecas 
estejam disponíveis no momento de execução. Para executarmos um programa 
sob controle do Waf, basta utilizarmos o comando “—run” no Waf. 
 
 
 
12 
Assim, para executarmos o equivalente do programa clássico de hello 
world no NS-3, devermos utilizar o comando: 
$ ./waf --run hello-simulator 
Ao executarmos este comando, o Waf primeiro irá verificar se o programa 
foi construído corretamente, e executará a sua compilação, se necessário. E 
então o Waf executará o programa, o que deverá produzir a seguinte saída: 
Hello Simulator 
Congratulations! You are now an ns-3 user! 
Porém, caso não seja mostrada a saída acima, deveremos então verificar 
quais são as possíveis causas da não exibição do texto. A primeira etapa é a 
verificação do processo de compilação. Assim, caso tenham sido exibidas as 
mensagens do Waf indicando que a compilação foi concluída com sucesso, mas 
não foi mostrada a saída do Hello Simulator, uma das possibilidades é a de que 
tenha sido mudado o modo de compilação para o modo otimizado (optimized), 
na seção de construção, Building, com o Waf, mas foi perdida a mudança de 
volta para o modo de depuração, debug. Todas as saídas de console 
consideradas neste nosso material está baseada na utilização de um 
componente especial de registro do NS-3, que é útil para imprimir mensagens 
do usuário para o console. Porém, a saída desse componente é 
automaticamente desativada quando é realizada a compilação de código 
otimizado. Assim, se não foi exibida a saída do Hello Simulator, devermos digitar 
o comando: 
$ ./waf configure --build-profile=debug --enable-
examples --enable-tests 
Com esse comando, estaremos configurando o Waf para construir as 
versões de depuração dos programas do NS-3 que incluem os exemplos e 
testes. Porém, ainda será necessário construirmos a versão de depuração real 
do código, digitando o comando: 
$ ./waf 
Agora, se executarmos novamente o programa Hello-simulator, 
deveremos ver a saída esperada. 
 
 
 
13 
3.1 Argumentos do programa 
Uma forma usual empregada na execução de programas é o fornecimento 
de parâmetros que serão empregados na execução destes. Assim, para a 
execução dos programas do NS-3, poderemos também fornecer os argumentos 
a serem utilizados, de acordo com o programa executado. Para isso, ou seja, 
para a execução de um determinado programa ns-3, deveremos utilizar a 
seguinte linha de comando: 
$ ./waf --run <ns3-program> --command-template="%s <args>" 
Para a aplicação do comando acima, devermos substituir o parâmetro 
indicado como <ns3-program> pelo nome do programa a ser executado, e os 
parâmetros <args> deverão incluir então os argumentos desejados. O 
argumento “--command-template” representa para o Waf o modo básico para 
compor a linha de comando real do Waf, que será utilizada para executar o 
programa desejado. O Waf irá então verificar se a compilação está concluída, 
definirá os caminhos da biblioteca compartilhada necessária e acionará o 
executável, com base nos parâmetros especificados no modelo de linha de 
comando apresentado acima, devendo ser inserido o nome do programa a ser 
executado no espaço reservado, que é indicado pelo parâmetro “%s”. 
Um outro exemplo que poderá ser bastante útil é a execução de uma suíte 
de teste por si só. Assim, supondo que existe uma suíte de teste chamada de 
mytest, utilizaremos então o script ./test.py para executar uma série de testes em 
paralelo, rodando repetidamente o programa de teste real, chamado de test-
runner. Para invocar o test-runner diretamente, para a execução de um único 
teste, temos o seguinte comando: 
$ ./waf --run test-runner --command-template="%s --
suite=mytest --verbose" 
Com o comando exemplificado, teremos a passagem dos argumentos 
para o programa chamado test-runner. No entanto, se executarmos este 
comando, como o mytest não existe, será gerada uma mensagem de erro. E se 
quisermos visualizar as opções disponíveis para o test-runner, deveremos 
utilizar o comando: 
$ ./waf --run test-runner --command-template="%s --
help" 
 
 
14 
3.2 Depuração 
Na execução dos programas do NS-3 pode ser interessante executarmos 
esses programas sob o controle de outro utilitário, tal como um depurador, por 
exemplo, o gdb, ou utilizando um verificador de memória, tal como o Valgrind, 
por exemplo. Nesses casos utilizaremos um parâmetro no formato semelhante 
ao mostrado abaixo: 
--command-template="..." 
Por exemplo, para executarmos o programa NS-3 chamado hello-
simulator, utilizando os argumentos <args>, e com a execução sob o depurador 
gdb, utilizaremos o seguinte comando: 
$ ./waf --run=hello-simulator --command-template="gdb 
%s --args <args>" 
Neste exemplo, podemos observar que o nome do programa do NS-3 
acompanha o argumento “—run”, e o utilitário de controle, que, nesse caso, é o 
depurador gdb, que é o primeiro parâmetro do argumento “--command-template”. 
E, finalmente, o argumento “—args” informa ao diz ao gdb que o restante da linha 
de comando pertence ao programa inferior. Porém, alguns gdbs não entendem 
o recurso -args, e nesse caso, deverão ser omitidos os argumentos do programa 
do “--command-template” e sendo utilizado o conjunto da args para o comando 
gdb. 
Poderemos também combinar este exemplo em conjunto com o anterior, 
para executar um teste com o recurso do depurador. Para isso, utilizaríamos o 
comando: 
$ ./waf --run test-runner --command-template="gdb %s -
-args --suite=mytest --verbose" 
3.3 Diretório de trabalho 
Para a correta operação do Waf, é necessário que ele seja executado 
estando localizado no topo da árvore do NS-3. Assim, esse espaço será o nosso 
diretório de trabalho, onde todos os arquivos de saída serão gravados. 
No entanto, caso desejarmos que esses resultados sejam enviados para 
a árvore onde está a fonte do NS-3, podemos alterar este caminho de gravação 
dos resultados, utilizando o argumento “—cwd”, conforme mostrado a seguir: 
 
 
15 
$ ./waf --cwd=... 
Além disso, pode ser mais conveniente começarmos a execução partir do 
diretório de trabalho, onde desejamos que os arquivos de saída sejam gravados. 
Assim, nesse caso, podemos utilizar uma referência indireta, conforme mostrado 
nos comandos a seguir: 
$ function waff { 
 CWD="$PWD" 
 cd $NS3DIR >/dev/null 
 ./waf --cwd="$CWD" $* 
 cd - >/dev/null 
 } 
Dessa forma, com o aperfeiçoamento do comando mostrado no exemplo 
anterior, teremos a gravação do resultado no diretório de trabalho atual, com a 
mudança para o diretório Waf, por meio do comando “cd”, que, em seguida, 
instrui o Waf a mudar o diretório de trabalho, de volta para o diretório de trabalho 
atual salvo, antes de executar o programa. 
TEMA 4 – COMPONENTES DO NS3 
Antes de começarmos a desenvolver os projetos no NS-3, por meio da 
elaboração dos códigos, é necessário entendermos os principais conceitos 
envolvidos, bem comoas abstrações no sistema. Apesar de esses conceitos 
poderem parecer muito óbvios, pois já foram trabalhados em outras disciplinas 
deste curso, iremos apresentá-los novamente para garantir que tenhamos uma 
boa base de conhecimento, necessária para elaboração dos projetos. 
Assim, neste tema, apresentaremos as abstrações-chave, que incluem os 
termos que são comumente utilizados nas redes, mas que apresentam um 
significado específico no desenvolvimento dos projetos de simulação, a serem 
elaborados com o NS-3. 
4.1 Os nós 
Na representação dos componentes das redes de dados, um dispositivo 
de computação que se conecta a uma rede é chamado de host ou também de 
dispositivo ou sistema final. Como o NS-3 é um simulador de rede, e não 
especificamente um simulador de internet, é empregado então o termo mais 
 
 
16 
genérico, também usado por outros simuladores, que se origina na teoria gráfica, 
que é o nó. 
Assim, no NS-3 é utilizada esta abstração básica do dispositivo de 
computação, que é chamado de nó. Como a base para elaboração dos projetos 
é a linguagem de programação C++, essa abstração será representada em C++ 
pela classe chamada de Node. Desta forma, a classe Node fornecerá os 
métodos para gerenciar as representações dos diversos dispositivos de 
computação, que poderão ser empregados nas simulações. 
Podemos então pensar em um Node como sendo um computador ao qual 
adicionaremos as diversas funcionalidades. Assim, poderemos acrescentar os 
diversos componentes e recursos que podem ser utilizados em um computador 
real, tal como os aplicativos, as pilhas de protocolo e as interfaces dos 
periféricos, com seus drivers associados, para permitir que o computador opere 
de maneira útil dentro do ambiente de simulação. 
Aqui podemos ressaltar uma diferença significativa entre o simulador NS-
3 e o simulador Packet Tracer, pois na ferramenta da Cisco temos os nós já 
predefinidos pela plataforma, com os recursos que já estão inseridos no código 
fonte do programa (CISCO, 2021). Dessa forma, a única solução para a evolução 
dos recursos disponibilizados no simulador Packet Tracer é a instalação de uma 
nova versão do software que contenha os recursos desejados. Já no ambiente 
de simulação do NS-3, para a atualização dos recursos de um Node, bastaria 
carregarmos as novas funcionalidades, atribuindo-as à classe Node em questão. 
Obviamente, esses recursos adicionais também deverão ser desenvolvidos 
como códigos, em linguagem de programação, de forma que possam ser 
adicionados ao ambiente de simulação do NS-3. 
4.2 Aplicações 
Outro componente a ser definido em um ambiente de simulação é o 
software que será executado nos nós que representam os computadores. 
Normalmente o software do computador é dividido em duas camadas distintas. 
O sistema operacional é o software que organiza os vários recursos do 
computador, tais como memória, ciclos de processadores, disco, rede, e outros, 
de acordo com o modelo de computador utilizado. E o software do sistema 
operacional geralmente não utiliza esses recursos para executar tarefas que 
beneficiam diretamente o usuário. Assim, o usuário normalmente deverá 
 
 
17 
executar um aplicativo, o qual irá utilizar os recursos, que são controlados pelo 
software do sistema operacional, para atingir o seu objetivo. 
Normalmente, a linha divisória entre o sistema operacional e o software 
aplicativo é definida pela mudança de nível de privilégio, o que acontece nos 
traps do sistema operacional. Porém, no ambiente de simulação do NS-3 não 
existe um conceito real de Sistema Operacional e, especialmente, não existe 
nenhum conceito associado aos níveis de privilégio, ou chamadas do sistema. 
No entanto, poderemos aplicar o conceito de execução de aplicações nos 
computadores que serão implementados dentro do ambiente de simulação. 
Dessa forma, assim como temos os aplicativos de software sendo executados 
em computadores, para executar tarefas no “mundo real”, os aplicativos do NS-
3 poderão também ser executados nos Nodes do NS-3, para realizar as 
simulações da execução dos aplicativos, porém no ambiente simulado. 
Dessa forma, em relação aos softwares, teremos o aplicativo, que será 
uma abstração básica do NS-3 para um programa de usuário e que irá gerar 
alguma atividade a ser simulada no ambiente do projeto de simulação. Assim 
como no caso dos Nodes, a representação dessa abstração também será feita 
com a utilização das classes. Portanto, essa abstração do aplicativo, a ser 
executada em um computador, será representada em C++ pela classe chamada 
de Application, a qua fornecerá então os métodos necessários para gerenciar as 
representações dessa versão de aplicativos, de nível de usuário, na execução 
das simulações. 
As aplicações que podem ser simuladas no ambiente do NS-3 dependem 
da colaboração dos desenvolvedores que colaboram para o projeto NS-3. Assim, 
espera-se que os desenvolvedores especializem cada vez mais a classe 
Application, empregando as ferramentas de programação orientada a objetos, 
criando cada vez mais novos aplicativos. Para os exemplos seguintes 
utilizaremos as especializações da classe Application que são chamados de 
UdpEchoClientApplication e UdpEchoServerApplication. Como o próprio nome 
indica, esses aplicativos fazem parte de um conjunto de aplicativos, do tipo 
cliente/servidor, que podem ser utilizados para gerar as mensagens de envio e 
de resposta de eco em um ambiente simulado de rede. 
Portanto, assim como em um ambiente real de rede, temos o comando 
ping, que gera as mensagens ICMP de echo request e de echo reply, para o 
ambiente simulado pelo NS-3 teremos uma especialização da classe Application, 
 
 
18 
que executará esta mesma operação. Porém, no ambiente de simulação, a 
execução deste aplicativo deverá ser incluída no script de uma simulação do NS-
3, que será então compilada, gerando o resultado da simulação em um arquivo 
binário, conforme vimos anteriormente. 
4.3 Canais 
Na composição das redes reais, temos os equipamentos terminais de 
usuário, que serão representados pelos Nodes no ambiente de simulação do NS-
3, os equipamentos intermediários de rede, que são os switches e roteadores, e 
temos também os meios físicos que implementam a conexão entre os 
equipamentos terminais e os equipamentos intermediários. Este meio de 
comunicação entre os equipamentos também é chamado de canal. Um exemplo 
usual desse canal é o caminho do cabeamento estruturado, em uma rede 
corporativa, que permite a conexão dos usuários até os equipamentos de acesso 
à rede, que são os switches de acesso. Essa comunicação ocorre utilizando um 
meio físico – nesse exemplo, o cabo de par trançado e um protocolo de 
comunicação, que é o Ethernet, que define também o padrão dos sinais elétricos 
que irão trafegar no cabo. 
Dessa forma, para o ambiente de simulação também necessitaremos 
representar essas conexões entre os equipamentos, e assim, no mundo 
simulado do NS-3, iremos conectar um nó, que é o Node, a um objeto que 
representará este canal de comunicação. Portanto, no NS-3 a abstração básica 
de uma sub-rede de comunicação é chamada de canal, e será representada no 
C++ pela classe chamada de Channel. 
Assim a classe Channel fornecerá os métodos para gerenciar os objetos 
de sub-rede de comunicação, permitindo a conexão dos Nodes a estes objetos. 
Assim como os Nodes, os Channels especializados também podem ser criados 
pelos desenvolvedores, empregando as ferramentas de programação orientada 
a objetos. Poderemos ter uma especialização do Channel modelando algo tão 
simples como uma conexão física implementada por um fio quanto objetos mais 
avançados e complexos. Por exemplo, um Channel especializado também pode 
modelar coisas tão complicadas quanto um grande switch Ethernet, ou até 
mesmo o espaço tridimensional, contendo diversas obstruções, simulando um 
ambiente de redes sem fio.19 
Como exemplo de Channel, neste material, utilizaremos as versões 
especializadas de Channel chamadas de Csma Channel, Point-to-Point Channel 
e WifiChannel. O Channel especializado chamado de Csma Channel, por 
exemplo, como o próprio nome indica, pode ser empregado para modelar uma 
sub-rede de comunicação do tipo múltiplo acesso, que emprega o controle de 
acesso ao meio através de detecção de portadora. Dessa forma, temos uma 
Channel que permitirá implementarmos no ambiente de simulação uma 
funcionalidade semelhante ao padrão Ethernet. 
4.4 Dispositivos de rede 
Nas primeiras gerações de computadores, era comum a necessidade de 
instalação de uma placa de interface de rede, chamada de NIC – Network 
Interface Card, para a conexão do computador a uma rede local. Atualmente os 
computadores já possuem essas interfaces incorporadas à placa principal, 
sendo isso transparente para o usuário. No entanto, uma interface do tipo NIC 
não funcionará corretamente sem a instalação de um driver de software, que fará 
o controle deste hardware. No sistema operacional Unix, ou Linux, um 
componente de hardware é um periférico classificado como um device. Assim, 
os dispositivos em geral serão controlados com a utilização dos drivers de 
dispositivos, e os dispositivos de rede, que são as interfaces de rede, chamadas 
de NICs, serão controlados utilizando-se os drivers de dispositivos de rede, 
conhecidos como net devices. Nos sistemas operacionais Unix e Linux nos 
referenciamos a estes dispositivos de rede com termos tais como eth0, fazendo 
referência ao padrão da interface que é o Ethernet, acrescida de um identificador 
sequencial (neste exemplo, a interface zero). Assim, se tivéssemos mais uma 
interface de rede, essa interface poderia ser identificada como eth1. 
No ambiente de simulação do NS-3, a abstração do dispositivo de rede 
inclui tanto o driver de software, para a interface de rede, quanto o hardware que 
será simulado. Desta forma, um dispositivo de rede é “instalado” em um nó, 
chamado de Node, permitindo que este nó possa se comunicar com os outros 
nós, no ambiente de simulação, o que será feito por meio dos canais, chamados 
de Channels. Assim, da mesma forma como um computador real pode se 
conectar a vários canais de rede, por meio de várias placas de rede, no ambiente 
de simulação do NS-3 um Node poderá ser conectado a mais de um Channel 
através de vários NetDevices. 
 
 
20 
Para a representação do dispositivo de rede, em sua abstração no 
ambiente de simulação do NS-3, teremos no C++ uma classe que é chamada de 
NetDevice, a qual fornecerá os métodos necessários para gerenciar as conexões 
com os objetos do tipo Node e do tipo Channel. Esta classe também poderá 
apresentar diversas especializações, a serem criadas pelos desenvolvedores, 
com a utilização de ferramentas de programação orientadas a objetos. Em 
nossos exemplos, utilizaremos as versões especializadas do NetDevice 
chamada CsmaNetDevice, PointToPointNetDevice e WifiNetDevice. 
Nos NetDevices, da mesma forma como uma interface de rede do tipo 
Ethernet, chamada de NIC Ethernet, foi projetada para se conectar e operar em 
uma rede que utiliza o padrão Ethernet, o dispositivo CsmaNetDevice foi 
desenvolvido para operar com um canal do tipo CsmaChannel, o dispositivo 
PointToPointNetDevice foi desenvolvido para operar com um canal do tipo 
PointToPointChannel e o dispositivo WifiNetDevice foi desenvolvido para operar 
com um canal do tipo WifiChannel. 
4.5 Assistente de topologia 
Nas redes reais, teremos os computadores, chamados de hosts, com as 
interfaces de rede, que são as NICs, sendo adicionadas ao equipamento ou já 
incorporadas. Da mesma maneira, no ambiente do NS-3 teremos então os 
Nodes com os NetDevices anexados, sendo que na simulação de uma rede de 
grande porte, será necessário organizarmos muitas conexões entre Nodes, 
NetDevices e Channels. 
Desse modo, a conexão dos NetDevices aos Nodes, a conexão dos 
NetDevices aos Channels e a atribuição dos endereços IP são tarefas bastante 
comuns no NS-3, para as quais teremos os chamados assistentes de topologia, 
conhecidos por topology helpers, que facilitarão esse processo de configuração 
das conexões. Por exemplo, poderá ser necessário realizarmos muitas 
operações distintas no ambiente do NS-3 para criar um NetDevice, adicionar um 
endereço MAC a este dispositivo, instalar esse dispositivo de rede em um Node, 
configurar a pilha de protocolo do Node e, em seguida, conectar o NetDevice a 
um Channel. Se tivermos que conectar vários dispositivos em canais de vários 
pontos, para, em seguida, conectar as redes individuais em redes maiores, que 
são as chamadas internetworks, teremos uma grande quantidade de operações 
a serem realizadas. Nesse cenário, poderemos então utilizar os objetos 
 
 
21 
chamados de topology helpers, que combinam essas diversas operações 
distintas em um modelo fácil de usar, tornando o processo de configuração muito 
mais ágil e prático. 
TEMA 5 – EXECUTANDO OS SCRIPTS 
Tendo sido realizado o download, conforme visto anteriormente, teremos 
então uma versão do NS-3 em um diretório chamado repos, que estará dentro 
do diretório home. E ao mudarmos para o diretório do NS-3, teremos uma 
estrutura de diretório, conforme mostrado a seguir: 
AUTHORS examples scratch utils waf.bat* 
bindings LICENSE src utils.py waf-tools 
build ns3 test.py* utils.pyc wscript 
CHANGES.html README testpy-output VERSION wutils.py 
doc RELEASE_NOTES testpy.supp waf* wutils.pyc 
Se mudarmos para o diretório examples/tutorial, encontraremos um 
arquivo chamado first.cc, localizado neste diretório. Este é um script que criará 
uma conexão simples, com um link ponto a ponto entre dois nós, e fará o eco de 
um único pacote entre estes nós. 
Podemos então verificar este script, conforme mostrado a seguir: 
 
 
22 
 
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ 
 2 /* 
 3 * This program is free software; you can redistribute it and/or 
modify 
 4 * it under the terms of the GNU General Public License version 2 as 
 5 * published by the Free Software Foundation; 
 6 * 
 7 * This program is distributed in the hope that it will be useful, 
 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
 10 * GNU General Public License for more details. 
 11 * 
 12 * You should have received a copy of the GNU General Public License 
 13 * along with this program; if not, write to the Free Software 
 14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
1307 USA 
 15 */ 
 16 
 17 #include "ns3/core-module.h" 
 18 #include "ns3/network-module.h" 
 19 #include "ns3/internet-module.h" 
 20 #include "ns3/point-to-point-module.h" 
 21 #include "ns3/applications-module.h" 
 22 
 23 // Default Network Topology 
 24 // 
 25 // 10.1.1.0 
 26 // n0 -------------- n1 
 27 // point-to-point 
 28 // 
 29 
 30 using namespace ns3; 
 31 
 32 NS_LOG_COMPONENT_DEFINE ("FirstScriptExample"); 
 33 
 34 int 
 35 main (int argc, char *argv[]) 
 36 { 
 37 CommandLine cmd (__FILE__); 
 38 cmd.Parse (argc, argv); 
 39 
 
https://www.nsnam.org/doxygen/namespacens3.html
https://www.nsnam.org/doxygen/group__logging.html#ga225a95395fa117b7309aa3c43518d02e
https://www.nsnam.org/doxygen/classns3_1_1_command_line.html
https://www.nsnam.org/doxygen/namespacesecond.html#ae84c87468c0e4398eab4dbb6cadc17d9
https://www.nsnam.org/doxygen/namespacesecond.html#ae84c87468c0e4398eab4dbb6cadc17d9
 
 
23 
 
A seguir, analisaremos cada uma das etapas do arquivo de simulação, 
identificando as funções empregadas e as formas de parametrizaçãodo 
ambiente de simulação. 
5.1 Topologia e canal 
Neste exemplo temos uma topologia ponto a ponto, incluído dois nós de 
rede, que simulam dois dispositivos terminais, que poderiam ser um servidor e 
um computador. 
A primeira etapa de configuração, atendendo às boas práticas 
recomendadas, é a documentação da topologia, que é representada no início do 
arquivo. Assim, essa representação é realizada no formato de comentário, 
utilizando as barras, que são interpretadas pelo C++ como sendo uma linha de 
 40 Time::SetResolution (Time::NS); 
 41 LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO); 
 42 LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO); 
 43 
 44 NodeContainer nodes; 
 45 nodes.Create (2); 
 46 
 47 PointToPointHelper pointToPoint; 
 48 pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps")); 
 49 pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms")); 
 50 
 51 NetDeviceContainer devices; 
 52 devices = pointToPoint.Install (nodes); 
 53 
 54 InternetStackHelper stack; 
 55 stack.Install (nodes); 
 56 
 57 Ipv4AddressHelper address; 
 58 address.SetBase ("10.1.1.0", "255.255.255.0"); 
 59 
 60 Ipv4InterfaceContainer interfaces = address.Assign (devices); 
 61 
 62 UdpEchoServerHelper echoServer (9); 
 63 
 64 ApplicationContainer serverApps = echoServer.Install (nodes.Get (1)); 
 65 serverApps.Start (Seconds (1.0)); 
 66 serverApps.Stop (Seconds (10.0)); 
 67 
 68 UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9); 
 69 echoClient.SetAttribute ("MaxPackets", UintegerValue (1)); 
 70 echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0))); 
 71 echoClient.SetAttribute ("PacketSize", UintegerValue (1024)); 
 72 
 73 ApplicationContainer clientApps = echoClient.Install (nodes.Get (0)); 
 74 clientApps.Start (Seconds (2.0)); 
 75 clientApps.Stop (Seconds (10.0)); 
 76 
 77 Simulator::Run (); 
 78 Simulator::Destroy (); 
 79 return 0; 
 80 } 
https://www.nsnam.org/doxygen/classns3_1_1_time.html#ac89165ba7715b66017a49c718f4aef09
https://www.nsnam.org/doxygen/classns3_1_1_time.html#a87a7f4d29c68b047a72d291ad660295aae324232af1b8cf625cecd92a22e0f2dc
https://www.nsnam.org/doxygen/namespacens3.html#adc4ef4f00bb2f5f4edae67fc3bc27f20
https://www.nsnam.org/doxygen/namespacens3.html#aa6464a4d69551a9cc968e17a65f39bdbae36aedc880de94fd5a5b53bb9fe65628
https://www.nsnam.org/doxygen/namespacens3.html#adc4ef4f00bb2f5f4edae67fc3bc27f20
https://www.nsnam.org/doxygen/namespacens3.html#aa6464a4d69551a9cc968e17a65f39bdbae36aedc880de94fd5a5b53bb9fe65628
https://www.nsnam.org/doxygen/classns3_1_1_node_container.html
https://www.nsnam.org/doxygen/namespacefirst.html#ae7e35c5f46b164552b3757279b479b72
https://www.nsnam.org/doxygen/namespacefirst.html#ae7e35c5f46b164552b3757279b479b72
https://www.nsnam.org/doxygen/classns3_1_1_point_to_point_helper.html
https://www.nsnam.org/doxygen/namespacefirst.html#a8b02169032fadfac35a7d60f8af13cee
https://www.nsnam.org/doxygen/namespacefirst.html#a8b02169032fadfac35a7d60f8af13cee
https://www.nsnam.org/doxygen/classns3_1_1_string_value.html
https://www.nsnam.org/doxygen/namespacefirst.html#a8b02169032fadfac35a7d60f8af13cee
https://www.nsnam.org/doxygen/classns3_1_1_string_value.html
https://www.nsnam.org/doxygen/classns3_1_1_net_device_container.html
https://www.nsnam.org/doxygen/namespacefirst.html#aceeeceb5543d091ced987748a578b8b9
https://www.nsnam.org/doxygen/namespacefirst.html#aceeeceb5543d091ced987748a578b8b9
https://www.nsnam.org/doxygen/namespacefirst.html#a8b02169032fadfac35a7d60f8af13cee
https://www.nsnam.org/doxygen/namespacefirst.html#ae7e35c5f46b164552b3757279b479b72
https://www.nsnam.org/doxygen/classns3_1_1_internet_stack_helper.html
https://www.nsnam.org/doxygen/namespacefirst.html#adc1ab139ff29103499c3f54f3e77189d
https://www.nsnam.org/doxygen/namespacefirst.html#adc1ab139ff29103499c3f54f3e77189d
https://www.nsnam.org/doxygen/namespacefirst.html#ae7e35c5f46b164552b3757279b479b72
https://www.nsnam.org/doxygen/classns3_1_1_ipv4_address_helper.html
https://www.nsnam.org/doxygen/namespacefirst.html#a121ad9b1005eb06f5256201299b392b2
https://www.nsnam.org/doxygen/namespacefirst.html#a121ad9b1005eb06f5256201299b392b2
https://www.nsnam.org/doxygen/classns3_1_1_ipv4_interface_container.html
https://www.nsnam.org/doxygen/namespacefirst.html#afaefcf75c4bb94d09c33c70154f34b99
https://www.nsnam.org/doxygen/namespacefirst.html#a121ad9b1005eb06f5256201299b392b2
https://www.nsnam.org/doxygen/namespacefirst.html#aceeeceb5543d091ced987748a578b8b9
https://www.nsnam.org/doxygen/classns3_1_1_udp_echo_server_helper.html
https://www.nsnam.org/doxygen/namespacefirst.html#a9ab3fb8f52b1c394c18b4ef01a647587
https://www.nsnam.org/doxygen/classns3_1_1_application_container.html
https://www.nsnam.org/doxygen/namespacefirst.html#a7f218a89ef0b389ab7f3f1f3d9e58a21
https://www.nsnam.org/doxygen/namespacefirst.html#a9ab3fb8f52b1c394c18b4ef01a647587
https://www.nsnam.org/doxygen/namespacefirst.html#ae7e35c5f46b164552b3757279b479b72
https://www.nsnam.org/doxygen/namespacefirst.html#a7f218a89ef0b389ab7f3f1f3d9e58a21
https://www.nsnam.org/doxygen/group__timecivil.html#ga33c34b816f8ff6628e33d5c8e9713b9e
https://www.nsnam.org/doxygen/namespacefirst.html#a7f218a89ef0b389ab7f3f1f3d9e58a21
https://www.nsnam.org/doxygen/group__timecivil.html#ga33c34b816f8ff6628e33d5c8e9713b9e
https://www.nsnam.org/doxygen/classns3_1_1_udp_echo_client_helper.html
https://www.nsnam.org/doxygen/namespacefirst.html#a07b401ed2173d09efb5d6d4b2413f240
https://www.nsnam.org/doxygen/namespacefirst.html#afaefcf75c4bb94d09c33c70154f34b99
https://www.nsnam.org/doxygen/namespacefirst.html#a07b401ed2173d09efb5d6d4b2413f240
https://www.nsnam.org/doxygen/classns3_1_1_uinteger_value.html
https://www.nsnam.org/doxygen/namespacefirst.html#a07b401ed2173d09efb5d6d4b2413f240
https://www.nsnam.org/doxygen/classns3_1_1_time_value.html
https://www.nsnam.org/doxygen/group__timecivil.html#ga33c34b816f8ff6628e33d5c8e9713b9e
https://www.nsnam.org/doxygen/namespacefirst.html#a07b401ed2173d09efb5d6d4b2413f240
https://www.nsnam.org/doxygen/classns3_1_1_uinteger_value.html
https://www.nsnam.org/doxygen/classns3_1_1_application_container.html
https://www.nsnam.org/doxygen/namespacefirst.html#ac96f3753c41e5e71c3f8775b0766709c
https://www.nsnam.org/doxygen/namespacefirst.html#a07b401ed2173d09efb5d6d4b2413f240
https://www.nsnam.org/doxygen/namespacefirst.html#ae7e35c5f46b164552b3757279b479b72
https://www.nsnam.org/doxygen/namespacefirst.html#ac96f3753c41e5e71c3f8775b0766709c
https://www.nsnam.org/doxygen/group__timecivil.html#ga33c34b816f8ff6628e33d5c8e9713b9e
https://www.nsnam.org/doxygen/namespacefirst.html#ac96f3753c41e5e71c3f8775b0766709c
https://www.nsnam.org/doxygen/group__timecivil.html#ga33c34b816f8ff6628e33d5c8e9713b9e
https://www.nsnam.org/doxygen/classns3_1_1_simulator.html#a84be982e6d03b62c3dc3303c75a9b909
https://www.nsnam.org/doxygen/classns3_1_1_simulator.html#a2a056e59a6623225df0957eda0ee8252
 
 
24 
comentário, que não será compilada/executada. A documentação é realizada 
pelas linhas mostradas a seguir: 
// Default Network Topology 
// 
// 10.1.1.0 
// n0 -------------- n1 
// point-to-point 
// 
Na parte superior da conexão entre os dois nós, que representa o canal 
entre o nó n0 e o nó n1, temos a indicação do endereçamento da rede, que nesse 
caso é a rede 10.1.1.0, e na parte inferior da conexão, temos a documentação 
do tipo de conexão, que é topologia ponto a ponto. 
Para a conexão entre os nós, temos a definição do link ponto a ponto, com 
uma largura de banda de 5Mbps e com um atraso de propagação de 2ms, 
conforme mostrado abaixo: 
PointToPointHelper pointToPoint; 
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps")); 
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms")); 
A classe identificada como PointToPointHelper irá criar uma redeponto a ponto identificada pelo parâmetro incluído no comando, que, nesse caso, 
é a rede chamada de “pointToPoint”. 
E para a utilização desta classe foi incluído neste projeto a biblioteca que 
contém essa classe, o que pode ser visto nas linhas iniciais do programa de 
simulação, que, nesse caso, é a linha: 
#include "ns3/point-to-point-module.h" 
Para a parametrização desse componente criado, deverá então ser 
utilizado o comando que irá definir os valores a serem atribuídos ao NetDevice 
criado, com o comando SetDeviceAttribute(), que nesse caso serão a 
taxa de transmissão, para o parâmetro “DataRate”, e o atraso, que 
corresponde ao parâmetro “Delay”. 
 
 
 
25 
5.2 Configuração dos nós 
A primeira etapa será a criação dos nós, que foi realizada com a utilização 
da classe NodeContainer, sendo criado o objeto chamado de nodes. Para a 
utilização desta classe foi incluída a biblioteca: 
#include "node-container.h" 
Para a parametrização desse objeto foi empregada a função 
nodes.Create (n), que define o número (n) de nós a serem criados, que 
nesse exemplo foi igual a dois. 
Na sequência, temos a criação dos dispositivos de rede, que serão 
instalados nos nós criados, semelhante ao processo de instalação de uma placa 
de rede à um computador. Para criação desses objetos, foi utilizada a classe 
NetDeviceContainer, que criou o objeto chamado de devices, mostrado na 
linha do programa, que é: 
NetDeviceContainer devices; 
Os dispositivos serão então conectados à rede ponto a ponto e 
associados aos nós criados, com a linha de programação: 
devices = pointToPoint.Install (nodes); 
A próxima etapa será a agregação das funcionalidades dos protocolos 
IP/TCP/UDP aos nós criados, com a utilização da classe 
InternetStackHelper para a criação do objeto stack, que foi então 
“instalado” nos nós, com a função stack.Install (nodes). 
Agora que já temos os nós criados, bem como os dispositivos de rede, 
que equivalem às placas de rede, instalados nos nós, e já tendo sido realizada 
a conexão entre os dispositivos de rede, por meio da rede ponto a ponto, e com 
a pilha de protocolos TCP/IP ativada, poderemos então realizar a configuração 
do endereçamento IP. Observe que todas as etapas realizadas, por meio da 
elaboração do código de programação para o NS-3, são semelhantes ao 
processo de instalação física necessária para a implementação de uma rede 
ponto a ponto, entre dois computadores reais. 
Para a configuração do endereçamento IP, é utilizada a classe 
Ipv4AddressHelper, que é um gerador de endereços IPv4 que irá garantir 
que não teremos endereços duplicados na rede. Neste exemplo, foi criado o 
 
 
26 
objeto identificado como address, que em seguida é configurado com os 
parâmetros que são o endereço da rede e a máscara de rede, com o comando 
address.SetBase ("10.1.1.0", "255.255.255.0"). 
Normalmente as interfaces IPv4 são instaladas nos dispositivos do NS-3 
utilizando o assistente de endereços Ipv4, tal como o Ipv4AddressHelper, 
utilizado na etapa anterior. O método de atribuição do assistente, que é 
designado como Assign(), irá utilizar um objeto do tipo NetDeviceContainer 
que contenha uma quantidade definida de Ptr<NetDevice>. E para cada um dos 
dispositivos de rede, que são os NetDevices, contidos no NetDeviceContainer, o 
assistente realizará uma associação entre o Ptr<Node> e o Ptr <Ipv4>. 
Após verificar que existe uma interface associada ao nó para o dispositivo 
de rede, então é adicionado um endereço IPv4, de acordo com as configurações 
do assistente de endereçamento, incrementando o endereço à medida que os 
endereços são atribuídos. O assistente então converte o Ptr<Ipv4> e o índice de 
interface em um “std::pair” e os adiciona a um contêiner do tipo IPv4. Assim, para 
realizar essa associação e armazenamento dos pares, a linha de comando será: 
Ipv4InterfaceContainer interfaces = address.Assign 
(devices); 
5.3 Execução da simulação 
Tendo sido realizada a configuração dos nós e da rede ponto a ponto, 
agora poderemos executar o teste de transmissão entre os nós, com o envio de 
mensagens de eco de um nó para o outro e com o envio das mensagens de 
resposta ao eco para o nó de origem. 
Para a geração desse tráfego será utilizada a classe 
UdpEchoServerHelper, que cria uma aplicação do tipo servidor, que aguarda por 
pacotes UDP de entrada e os envia de volta para o remetente original, que foi 
utilizado para a criação do objeto identificado como echoServer, na linha de 
programa: 
UdpEchoServerHelper echoServer (9); 
A próxima etapa será a criação do contêiner com as mensagens a serem 
armazenadas, resultantes do processo de comunicação. Para isso é utilizada a 
classe ApplicationContainer, que conterá o resultado do tráfego do nó onde será 
 
 
27 
executada a aplicação criada na etapa anterior, que é a resposta às mensagens 
recebidas. E esta aplicação será executada iniciando no tempo igual à 1 segundo 
e será encerrada no tempo igual à 10 segundos. Essas configurações são 
realizadas pelas linhas mostradas abaixo: 
ApplicationContainer serverApps = echoServer.Install 
(nodes.Get (1)); 
serverApps.Start (Seconds (1.0)); 
serverApps.Stop (Seconds (10.0)); 
Para a geração das mensagens de eco será utilizada a classe 
UdpEchoClientHelper, que cria uma aplicação que enviará pacotes UDP e 
aguardará o recebimento das respostas, de eco, aos pacotes enviados. Além da 
criação desse objeto, que é chamado de echoClient, também é necessário 
realizarmos a parametrização das mensagens. Neste exemplo, teremos então 
um pacote sendo enviado em intervalos de um segundo, e com tamanho de 1024 
bytes, conforme as linhas de programa mostradas abaixo. 
UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9); 
echoClient.SetAttribute ("MaxPackets", UintegerValue (1)); 
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0))); 
echoClient.SetAttribute ("PacketSize", UintegerValue (1024)); 
Criado o serviço de geração das mensagens de eco, a próxima etapa será 
a criação do contêiner que armazenará as mensagens enviadas e recebidas por 
este nó. Para isso, é utilizada novamente a classe ApplicationContainer, mas 
agora associando o objeto echoClient ao nó zero. E essa aplicação será 
executada iniciando no tempo igual a 2 segundos e será encerrada no tempo 
igual à 10 segundos, conforme mostrado abaixo: 
ApplicationContainer clientApps = echoClient.Install (nodes.Get (0)); 
clientApps.Start (Seconds (2.0)); 
clientApps.Stop (Seconds (10.0)); 
E, finalmente, para a execução da simulação, teremos o comando: 
Simulator::Run (); 
Assim o NS-3 realizará a execução do ambiente de simulação, até que 
todos os pacotes sejam enviados e recebidos pelos nós, de acordo com a 
temporização parametrizada no código do programa. 
 
 
28 
Para evitar relatórios falsos-positivos, deve-se acrescentar o método 
chamado de Simulator::Destroy (), que deve ser incluído no final de uma 
simulação. E após a execução deste método, será possível reiniciar uma nova 
simulação com um comando de execução Simulator::Run. 
FINALIZANDO 
O simulador NS-3 é uma ferramenta baseada em código de programação 
e, assim, demanda a criação de um ambiente de desenvolvimento e de 
compilação de programas. Portanto, para a instalação da ferramenta de 
simulação, é necessário inicialmente prepararmos esse ambiente. Caso 
contrário, quando elaborarmos os projetos de simulação, poderemos ter muitas 
mensagens de falha na construção do projeto, em função da falta de algum 
destes componentes. Inclusive, para identificar este tipo de problema, o NS3 
pode ser executado com a utilização de uma ferramenta de depuração, tal como 
o gdb, que irá gerar as mensagens necessárias para identificarmos as causas 
de falha e assim providenciarmos as correções necessárias. 
Para o download, temos basicamente três modos diferentes, que são a 
utilização do Bake, a utilização do git, para o ambientens-3-allinone, e a 
utilização do Traball, que é o processo mais simples, também baseado no 
download do ambiente ns-3-allinone. 
A outra ferramenta empregada será o WAF, que auxiliará na elaboração 
de projetos, permitindo a inclusão de vários parâmetros. Assim, poderemos 
definir o nível de depuração, realizar a desativação das ligações Python, além 
de fornecer os diversos argumentos que possam ser utilizados em um 
determinado projeto. Para a execução dos projetos, poderemos também utilizar 
um programa de controle, tal como um depurador ou uma ferramenta de 
verificação de memória, pois como o resultado da execução do projeto será a 
geração de um arquivo, caso os dados contidos neste arquivo não estejam 
coerentes com o resultado esperado, poderá ser necessária a utilização de uma 
ferramenta adicional, para identificar as possíveis causas destas diferenças. 
Para a elaboração do ambiente de realização da simulação, deveremos 
então construir o projeto, com a inclusão das bibliotecas e criação e 
parametrização dos nós, dos dispositivos de rede, dos canais e das aplicações, 
conforme visto no exemplo apresentado nesta aula, e que está incluso no pacote 
de componentes e ferramentas do NS3, disponível no site do projeto. Além disso, 
 
 
29 
na construção do projeto, é necessária a criação dos containers, para o 
armazenamento das mensagens, de forma que possa ser realizada a análise do 
resultado da simulação utilizando-se dos pacotes trafegados durante a execução 
da simulação. 
Como no ambiente real das redes, muitas vezes também são necessárias 
a captura e a análise do tráfego da rede. Para a avaliação do desempenho da 
rede, por sua vez, é necessária a utilização de uma ferramenta que possibilite a 
realização dessa tarefa. Assim, nas próximas aulas estudaremos o Wireshark, 
que é uma aplicação amplamente utilizada pelos profissionais da área de redes, 
sendo uma ferramenta essencial para o processo de análise de desempenho 
das redes. 
 
 
 
 
 
30 
REFERÊNCIAS 
CISCO – Networking Academy. Disponível em <https://www.netacad.com/pt-br>. 
Acesso em: 12 jul. 2021. 
NSAM. NS-3 Network Simulator. NSAM, S.d. Disponível em: 
<https://www.nsnam.org/>. Acesso em: 12 jul. 2021. 
TANEMBAUM, A. S. Redes de computadores. 2. ed. São Paulo: Pearson 
Education do Brasil, 2011.