Mudanças entre as edições de "ADS29009-2019-1"
Linha 1 278: | Linha 1 278: | ||
==Programa Simulação Cadeia Markov== | ==Programa Simulação Cadeia Markov== | ||
+ | |||
+ | TAREFA 8 - Simulação de Caddeia de Markov e comparação com resultado teórico de 05/06/2019 às 00h00 a 11/06/2019 às 23h59 Não 0 | ||
+ | |||
+ | Segundo discutido em sala e exercício do slide | ||
https://www.dropbox.com/s/hvgk42nhhcsyjlt/SimMarkovAlunos.m | https://www.dropbox.com/s/hvgk42nhhcsyjlt/SimMarkovAlunos.m | ||
Linha 1 295: | Linha 1 299: | ||
]; | ]; | ||
</syntaxhighlight> | </syntaxhighlight> | ||
+ | |||
+ | |||
+ | =AULA 20 == |
Edição das 07h41min de 11 de junho de 2019
AULA 1 - Dia 26/07/2018
- Apresentar e Discutir Plano de Ensino
- Conceitos em ADS
Plano de Ensino
SLIDES DA AULA
ATIVIDADE 1
PARTE 1
O código abaixo permite estimar o tempo de execução do programa (processo) para executar um determinado loop. Modificar o programa e gerar um gráfico mostrando a média do tempo de execução para uma faixa de 1 até 100 processos. Discutir o resultado. Postar no SIGAA um mini-relatório com:
- objetivo do experimento
- dados do PC utilizado (número de cores);
- código modificado;
- gráfico tempo médio x número de processos;
- discussão do resultado.
//Modificado de https://www.geeksforgeeks.org/measure-execution-time-with-high-precision-in-c-c/
- include <sys/time.h>
- include <sys/types.h>
- include <sys/wait.h>
- include <unistd.h>
- include <stdio.h>
int main()
{
long int i;
double tempo_bloco;
int status;
pid_t pid;
for (i=0;i<23;i++) {
if (fork()==0) {
struct timeval start, end;
gettimeofday(&start, NULL);
for (i=0; i<10000000000L; i++) { // loop de interesse
}
gettimeofday(&end, NULL);
tempo_bloco = (end.tv_sec - start.tv_sec) * 1e6;
tempo_bloco = (tempo_bloco + (end.tv_usec -
start.tv_usec)) * 1e-6;
printf("Tempo = %lf\n", tempo_bloco);
exit(0);
}
}
while ((pid = wait(&status))>0); //espera por todos os filhos terminarem
}
</syntaxhighlight>
PARTE 2
Projetar um experimento para verificar se o mecanismo nice (usando setpriority()) funciona conforme o esperado. Use o programa acima como base. Defina:
- os objetivos do experimento
- métricas
- parâmetros
- fatores
- Apresente e discuta os resultados.
Incluir a PARTE 2 no relatório do experimento.
AULA 2 - Dia 18/02/2019
- Continuação da Aula anterior: Conceitos Básicos de ADS
- ATIVIDADE 1
AULA 3 - Dia 20/02/2019
- Medição em Redes
Medição Ativa e Passiva em Redes
- Referência:
- Slides: Medição Ativa - Iperf
https://www.dropbox.com/s/38qy76phjob7a3o/Medi__oEmRedes.pdf?dl=0
ATIVIDADE 2
Implemente um experimento usando o iperf para:
- determinar a vazão máxima entre PC1 e PC3 usando o protocolo UDP;
- descobrir a janela "ótima" do TCP para maximizar a vazão entre PC1 e PC2;
Use a seguinte configuração do netkit:
- Definição das máquinas
R1[type]=router
PC1[type]=generic
PC2[type]=generic
PC3[type]=generic
- Definição dos roteadores padrão
PC1[default_gateway]=10.0.0.254
PC2[default_gateway]=10.0.1.254
PC3[default_gateway]=10.0.1.254
- Definição das interfaces do roteador
R1[eth0]=lan0:ip=10.0.0.254/24:rate=10000
R1[eth1]=lan1:ip=10.0.1.254/24:rate=10000
- Definição das interfaces dos PCs
PC1[eth0]=lan0:ip=10.0.0.1/24:rate=10000
PC2[eth0]=lan1:ip=10.0.1.2/24:rate=10000
PC3[eth0]=lan1:ip=10.0.1.3/24:rate=10000
</syntaxhighlight>
ATIVIDADE 3 - Questionário Medição Ativa x Passiva em Redes
1.Explique a diferença entre medição ativa e passiva em redes.
2.Liste os benefícios advindos da a aquisição de dados/avaliação de desempenho derivado da medição ativa ou passiva.
3.Descreva como o SNMP e RMON podem ser usados no contexto de medição em redes.
4.Apresente brevemente as sete métricas de desempenho IP proposta pela IETF (IP Performance Metrics - IPPM)
5.Em medição passiva existem problemas associados ao sigilo de dados. Discuta que problemas são estes e como podem ser contornados.
6.Em medição ativa normalmente se usa o conceito de "probes". Explique o que é e discuta características desejáveis de uma pacote probe. Discuta também o conceito de intrusão neste contexto.
7.Explique como é formado o tempo de retardo (delay) fim-a-fim na comunicação de dados.
8.Explique como é computada a capacidade de um caminho (fim-a-fim) de comunicação.
9.Qual conceito de banda disponível ("Available bandwidth"). Discuta a técnica PPTD (ou SLOPS ou TOPS). Faça um esquema/procedimento inicial de como pode ser usada esta técnica em um experimento real de medição de banda disponível.
Outras Referências
https://www.caida.org/publications/papers/2003/bwestmetrics/
AULA 4 - Dia 26/02/2019
Objetivos
- Discussão da Atividade 1: Definição do experimento, métricas, caracterização da carga de trabalho, parâmetros e fatores
- Medição Ativa e Passiva: Continuação
Links Interessantes
AULA 5 - Dia 13/03/2019
Objetivos
- Sumarização de Dados
- Confiança Estatística
https://www.dropbox.com/s/yrcsrmfbcukatwz/ConfiancaEstatisticav1.pdf?dl=0
TAREFA 4
- Exercícios dos slides conforme repassado em aula: data limite => 23/03/2019
AULA 6 - Dia 20/03/2019
Objetivos
- Sumarização de Dados
- Confiança Estatística
Exercício (TAREFA 5)
O código abaixo permite melhor enteder o conceito de Intervalo de Confiança (IC). Uma amostra de tamanho 33 é extraída de uma população normal com média e
desvio padrão conhecidos. O IC é calculado para um
nível de confiança de 95%.
1)Implemente um código adicional para que seja realizada 10000 computações (coleta de amostras - cada amostra com 33) de IC e para que seja verificado se o nível de confiança está sendo respeitado.
2) Pesquisar no matlab o equivalente a função norminv para a distribuição T-student. Aplicar o programa para resolver os intervalos solicitados no slide da aula (exemplo da fila).
3) Construir uma função para comparar dois sistemas baseando-se no intervalo de confiança. Serão fornecidos dois vetores com as medições (pareadas), bem como o nível de confiança desejado. A função deve retornar se existe (V) ou não diferença significativa para o nível de confiança desejado.
%code adapted from http://www2.cs.siu.edu/~qcheng/Teaching%20Software/Matlab%20Tutorials.pdf
n=33; % *Linha 1: simula o tamanho da amostra (por exemplo, 4 repetições de uma simulação do omnet)*
pm=12; ps=10; % *Linha 2: parâmetros de uma população normal: média 12 e desvio 10*
alfa=0.05; num_exp=100% *Linha 3: 1-alfa determina o nível de confiança
figure; hold on; % Linha 4: prepara uma figura*
for i=1:num_exp ; % Linha 5: Cada loop simula um experimento: a retirada de 100 conjuntos de amostras de tamanho n *
x=pm+ps*randn(n,1); % *Linha 6: retira as n observações da população. Em x estão n amostras*
mx=mean(x); % *Linha 7: faz a média das n amostras*
zcr=norminv(1-alfa/2,0,1); % *Linha 8 modificado código original - determina a referência superior para confiança de 0.05 - inversa da normal padrão*
sem=ps/sqrt(n); % *Linha 9: desvio padrão da média amostral*
me=zcr*sem; % *Linha 10: margem de erro para computação do intervalo de confiança*
CI1= mx-me; % Linha 11: limite inferior do intervalo de confiança*
CI2= mx+me; % Linha 12: limite superior do intervalo de confiança*
plot(i*ones(1,n), x, 'k.','markersize',5); % Linha 13: plotagem do intervalo*
plot(i*ones(1,2),[CI1, CI2],'g+') % show CI * Linha 14: plotagem do intervalo*
if pm<CI1 || pm>CI2 % Linha 15: intervalos que não contém a média da população!! *
plot(i,pm,'r*','markersize',10) %*Linha 16: ressaltado em vermelho*
end % *Linha 17*
end % Linha 18
xlabel('numero do experimento') % *Linha 19*
ylabel('observacoes ') % *Linha 20*
title(['95% CI:',num2str(mx,3),'\pm',num2str(me,3)]), shg % *Linha 21*
</syntaxhighlight>
AULA 7 - Dia 26/03/2019
Objetivos
- Introdução a Simulação com Eventos Discretos
- Simulação de Fila MM1 usando um Simulador Implementado em C/C++
Material de Referência
TAREFA 6
- Adaptar o código de tratamento de uma fila MM1 simples, conforme colocado no slide para um formato de um simulador de eventos discretos com filas. Use o código abaixo como apoio.
//Basead em http://stdcxx.apache.org/doc/stdlibug/2-2.html#225
#include <queue>
#include <iostream>
#include <cstdlib>
//==================================================================
// classes evento e simulação - base para o desenvolvimento da simulação
//==================================================================
class event {
public:
// Construct sets time of event.
event (double t) : time (t)
{ }
// Execute event by invoking this method.
virtual void processEvent () = 0;
const double time;
};
class simulation {
public:
simulation () : simtime (0), eventQueue ()
{}
void run ();
void scheduleEvent (event * newEvent) {
eventQueue.push (newEvent);
}
double simtime;
protected:
class eventComparator {
public:
bool operator() (const event * left, const event * right) const {
return left->time > right->time;
}
};
std::priority_queue<event*,
std::vector<event *, std::allocator<event*> >,
eventComparator> eventQueue; //fila de eventos
};
void simulation::run () {
while (! eventQueue.empty ()) { //enquanto exisitr eventos na fila de eventos
event * nextEvent = eventQueue.top (); //captura evento no topo da fila
eventQueue.pop (); //retira evento da fila
simtime = nextEvent->time; //ajusta tempo de simulação
nextEvent->processEvent (); //processa evento
delete nextEvent; //remove evento
}
}
//===================================================================
//Customização dos eventos e do simulador
//===================================================================
class standardArrival : public event {
public:
standardArrival (double t)
: event (t)
{ }
virtual void processEvent ();
};
void standardArrival::processEvent () {
std::cout << "processando evento no tempo " << time << '\n';
}
class simuladorFilas : public simulation {
public:
simuladorFilas ()
{ }
} oSimulador;
// from https://stackoverflow.com/questions/2704521/generate-random-double-numbers-in-c
double fRand(double fMin, double fMax)
{
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
int main () {
// Inicializar aqui a fila de eventos
double t;
oSimulador.scheduleEvent (new standardArrival (t=fRand(1.0,10.0)));
oSimulador.scheduleEvent (new standardArrival (t=t+fRand(1.0,10.0)));
oSimulador.scheduleEvent (new standardArrival (t=t+fRand(1.0,10.0)));
// Executar simulador
oSimulador.run ();
return 0;
}
AULA 8 - Dia 02/04/2019
Objetivos
- Implementação do Simulador a Eventos Discretos para Fila MM1
- Geração de Números Randômicos na Simulação
Material de Referência
Ainda Tarefa 6
- Na fila MM1 passada em aula, a distribuição dos tempos de chegada e dos tempos de serviço seguem uma distribuição exponencial. Na atividade 6 foi solicitado converter o código do simulador MM1 para uma estrutura de simulador a eventos discretos. Resta realizar esta geração randômica.
Para tanto, vamos seguir o método da função inversa da seguinte forma:
(1) Implementar uma classe de geração randômica uniforme segundo o método do polinômio congruente;
(2) Implementar uma classe de geração exponencial que se utiliza da classe anterior e implementa a função inversa (ver slides)
(3) Incorporar esta implementação no código do simulador.
- Implementar uma Classe de Geração de Números Randômicos a partir de uma distribuição exponencial usando o método da função inversa. Usar o método de polinômio congruente linear para geração da distribuição uniforme.
Código do Matlab para entendimento do método linear congruente
Código Matlab de Apoio
%parâmetros
a=7^5;
c=0;
x0=1;
m=2^31-1;
% zerar xn
xn=zeros(20000,1);
%gerar numeros
for i=1:10000
xn(i)=mod(a*x0+c,m);
x0=xn(i);
end
% ajustar para gerar entre 0 e 1
un=xn/m;
% plotar histograma
hist(un(1:10000),10);
</syntaxhighlight>
AULA 9 - Dia 03/04/2019
Objetivos
- Implementação do Simulador a Eventos Discretos para Fila MM1
- Geração de Números Randômicos na Simulação
Link Geração Randômica Linear Congruente
AULA 10 - Dia 16/04/2019
Objetivos
- Uso de um SImulador a Eventos Discretos para Redes: Omnet
- Tutorial Tic-Toc
- conceito de gates e de vetor de gates;
- envio de mensagens e de cópias de mensagens;
- Modelagem de Delays
- Uso de funções de geração de números randômicos
- Modelagem de retransmisssão: timeouts e cancelamento de timeout;
Considerações sobre a simulação com o omnet
No manual de simulação do Omnet pode-se observar que:
Eventos e Ordem de Execução
- mensagens são representadas por eventos (class cMessage) e subclasses;
- o tempo de ocorrência de um evento é o momento da chegada da mensagem (arrival time) no módulo de destino;
- timeouts serão implementados por um módulo emissor como mensagens para eles mesmos (self-messages);
- eventos são processados de acordo com o tempo de chegada (mensagens com tempo mais antigos primeiro) de forma a manter a relação de causalidade;
- Caso duas mensagens tenham o mesmo tempo de chegada tem-se que:
- a mensagem com maior prioridade atribuída pelo usuário é executada primeiro ( higher scheduling priority);
- caso tenham a mesma prioridade, será executada a que estiver primeiro na fila (escalonada pelo scheduler).
Referência
Acesso omnetpp na Cloud IFSC
- Contribuição de Gabriel de Souza/CTIC.
Fazer:
ssh SEU_USUARIO_LDAP@nuvem.sj.ifsc.edu.br -p 2223 -XC
$ omnetpp
Roteiro para Conceitos Básicos
USando o manual rever:
- 2.1 Conceitos de Modelagem
- Hierarquia de Módulos;
- Tipo Módulo;
- Links, Portos e Mensagens
- 2.4.Depuração do Código
- 2.5.Visualização da Troca de Mensagens após a Simulação (Sequence Chart)
Exercício após step 2
- Ler no manual sobre cPacket
- Modificar o tictoc1 para usar cPacket, configurando o tamanho do pacote para 10bits
- Ler no manual sobre Channel e como setar datarate
- Configurar o channel para datarate de 2bps e delay de 1bps
- Executar a simulação para algumas trocas de mensagens.
- Examinar o arquivo de elog e examinar os resultados. Como aparece o delay? O atraso de transmissão está coerente?
AULA 11 - Dia 17/04/2019
Objetivos
- Continuação Setp2. aa Step10
- Exercício Simulação camada IP
Para rodar sem IDE
ssh SEU_USUARIO_LDAP@nuvem.sj.ifsc.edu.br -p 2223 -XC
cd [diretorio_arquivos]
opp_makemake
make
./nome_arquivo_sim
Para record elog
Colocar no ini
record-eventlog = true
Tarefa
- Estudar o cPacket do omnet (estudar cMessage)
Aula 12 - Dia 24/04/2019
Objetivos
- Capacitar o aluno a:
- Mostrar graficamente variáveis associadas a métricas
- Coletar estatísticas (step 15)
- Visualizar as saídas de vetores e escalares;
- Consolidar o conhecimento explorando uma implementação de fila MM1 no omnet.
Procedimento
- Logar no servidor e seguir o tutorial com os alunos:
- Rever step 10 (vetor de módulos e gates, envio de mensagens com indexação), 11 e 12 (two way connections)
- Seguir Sptep 13 até o final
Exercício
A finalidade deste exercício é implementar um Modelo de Fila MM1 usando o Omnet de forma a:
- Analisar o delay de cada requisicação usando o arquivos vec
- Analisar o delay médio
- Explorar o conceito de Experimento/Medição/Run
- Modificar parâmetros de entrada do modelo
- Baseado em Paolo Giaccone
- Explorar funções getCreationTime, getTimestamp, setTimestamp do cMessage.
Preparação inicial
Versão Manual
$ mkdir MM1
$ cd MM1
Versão IDE
Seguir passos do tutorial tictoc para criação do projeto mas agora adaptando ao exemplo da MM1.
Arquivo mm1.ned
- Baseado em Paolo Giaccone
Criar mm1.ned:
// *** mm1.ned ***
simple Generator {
parameters:
volatile double interArrivalTime; // sec
@display("i=block/source");
gates:
output out;
}
simple Queue {
parameters:
volatile double serviceTime; // sec
@display("i=block/queue");
gates:
input in;
output out;
}
simple Sink {
parameters:
@display("i=block/sink");
gates:
input in;
}
network MM1 {
submodules:
gen: Generator{
@display("p=273,101");
}
queue: Queue{
@display("p=165,79");
}
sink: Sink{
@display("p=50,79");
}
connections:
gen.out --> queue.in;
queue.out --> sink.in;
}
</syntaxhighlight>
Arquivo generator.cc
- Baseado em Paolo Giaccone
Criar generator.cc:
/*** generator.cc ***/
#include <string.h>
#include <omnetpp.h>
using namespace omnetpp;
class Generator: public cSimpleModule {
private:
cMessage *sendMsgEvent;
public:
Generator(); // constructor
virtual ~Generator(); // destructor
protected:
virtual void initialize();
virtual void finish();
virtual void handleMessage(cMessage *msg);
};
Define_Module(Generator);
Generator::Generator() {
sendMsgEvent=NULL;
}
Generator::~Generator() {
cancelAndDelete(sendMsgEvent);
}
void Generator::initialize() {
// create the "send" packet
sendMsgEvent=new cMessage("sendEvent");
// schedule the first event at random time
scheduleAt(par("interArrivalTime"), sendMsgEvent);
}
void Generator::finish() {
}
void Generator::handleMessage(cMessage *msg) {
cMessage *pkt;
simtime_t departure_time;
// create new packet
pkt = new cMessage("packet");
// sent to the output
send(pkt,"out");
// compute the new departure time
departure_time=simTime()+par("interArrivalTime");
// schedule the new packet generation
scheduleAt(departure_time, sendMsgEvent);
}
Arquivo queue.cc
- Baseado em Paolo Giaccone
- NOTE que nesta implementação a requisição servida fica no topo da fila.
/*** queue.cc ***/
#include <string.h>
#include <omnetpp.h>
using namespace omnetpp;
class Queue : public cSimpleModule {
private:
// local variable
cQueue buffer;
cMessage *endServiceEvent;
simtime_t service_time;
public:
// constructor
Queue(); // constructor
virtual ~Queue(); // destructor
protected:
virtual void initialize();
virtual void finish();
virtual void handleMessage(cMessage *msg);
};
Define_Module(Queue);
Queue::Queue() {
endServiceEvent=NULL;
}
Queue::~Queue() {
cancelAndDelete(endServiceEvent);
}
void Queue::initialize() {
endServiceEvent=new cMessage("endService");
}
void Queue::finish() {}
void Queue::handleMessage(cMessage *msg) {
cMessage *pkt;
// if msg is endServiceEvent, then
//dequeue and send the pkt to the output
//if another pkt is available in the buffer, then
//start a new service
// if msg is a packet, then
//enqueue the pkt
//if server idling, then
//start a new service
if (msg==endServiceEvent) {
// dequeue
pkt=(cMessage*)buffer.pop();
// send
send(pkt,"out");
if (!buffer.isEmpty()) { // if another pkt is available
// start the service
service_time=par("serviceTime");
scheduleAt(simTime()+service_time,endServiceEvent);
}
} else { // msg is a packet
// enqueue
buffer.insert(msg);
// if the server is idling
if (!endServiceEvent->isScheduled()) {
// start the service
service_time=par("serviceTime");
scheduleAt(simTime()+service_time,endServiceEvent);
}
}
}
Arquivo sink.cc
/*** sink.cc ***/
#include <string.h>
#include <omnetpp.h>
using namespace omnetpp;
class Sink : public cSimpleModule {
private:
// online stats
cStdDev delayStats;
cOutVector delayVector;
public:
Sink(); // constructor
virtual ~Sink(); // destructor
protected:
virtual void initialize();
virtual void finish();
virtual void handleMessage(cMessage *msg);
};
Define_Module(Sink);
Sink::Sink() {}
Sink::~Sink() {}
void Sink::initialize() {
delayStats.setName("TotalDelay");
delayVector.setName("Delay");
}
void Sink::finish() {
recordScalar("Ave delay",delayStats.getMean());
recordScalar("Number of packets",delayStats.getCount());
}
void Sink::handleMessage(cMessage *msg) {
// compute queueing delay
simtime_t delay=simTime() - msg->getCreationTime();
// update stats
delayStats.collect(delay);
delayVector.record(delay);
// delete msg
delete(msg);
}
Arquivo omnet.ini
- omnetpp.ini
[General]
network = MM1
sim-time-limit = 100s
- .interArrivalTime=exponential(2)
- .serviceTime=exponential(0.8)
</syntaxhighlight>
Execução da Simulação
$ opp_makemake
$ make
$ ./MM1
Exercícios
- 1.Ler o manual de simulação do omnet Cap/Secão 10.4 (https://omnetpp.org/doc/omnetpp/manual/#sec:config-sim:parameter-studies)
- 2.Modificar o exemplo da fila acima para:
- Criar um sistema de filas encadeadas onde a saída de uma fila MM1 alimenta duas outras filas filas MM1 através de um spliter.
- A saída da primeira fila deve ser redirecionada para este splitter que reparte o tráfego segundo de forma parametrizável para as filas posteriores,
- 3.Mostrar um gráfico de barras comparando os "delays" (tempo no sistema) médios,máximo e mínimo de cada sistema MM1 e do sistema completo. A média deverá ser realizada sobre 5 repetições.
- 4.Parametrizações:
- Probabilidade a ser usada no splitter: 0.2 (MM1-B) e 0.8 (MM1-C)
- Generator: interarrival time: 1s
- Tempo de Serviço: primeiro MM1-A: 0.6s, MM1-B: 0.7s e MM1-C: 0.5s
Acesso Cloud
ssh SEU_USUARIO_LDAP@nuvem.sj.ifsc.edu.br -p 2223 -XC
Aula 13 - Dia 30/04/2019
Objetivos
- Construir uma rede de Filas MM1 usando o Omnet
- Gerar estatísticas sobre o tempo médio de espera no sistema em um ramo da fila;
- Usar as facilidades de repetição da simulação
- Gerar o intervalo de confiança para a medição realizada.
Modelo de Simulação desejado
A fila de MM1 a ser implementada segue o modelo abaixo. A geração de tráfego é Poisson e o serviço segue distribuição exponencial. 70% do tráfego gerado por queue0 é reconduzido para queue1 e 30% para queue2.
ETAPA 1
- Criar um projeto de simulação;
- Especificar o arquivo NED para criar a fila interligada:
ETAPA 2
- Incluir um arquivo generator.cc de forma similar ao da aula anterior.
ETAPA 3
- Modificar o arquivo queue.cc para o comportamento desejado: 70% do tráfego para queue1 e 30% para queue2.
ETAPA 4
Acrescentar o armazenamento de estatística. Para o tempo médio de espera no sistema precisamos apenas armazenar um escalar. Observando o código da aula anterior, pode-se observar que o cálculo do "delay" já é relativo a criação da mensagem. Então o retardo total em cada braço da fila já está sendo computado.
ETAPA 5
Acrescentar o omentpp.ini. Deixar os mesmos parâmetros da aula passada mas aumentar o tempode simulação para 10000s. Fazer um plot do tempo médio comparando os resultados. É possível tirar alguma conclusão?
ETAPA 6 - Acrescentando repetições e tempo de warmup.
Para acrescentar repetições no experimento podemos usar o parâmetro repeat no omnetpp.ini. Colocar 30 repetições. O tempo de warmup computa os dados somente após o período definido, de forma a eliminar transientes iniciais. Colocar warmup-period de 10s. Plotar e examinar os resultados.
repeat=30
warmup-period=10s
Para rodar a simulação com as repetições, deve-se desabilitar a interface gráfica: clicar com o mouse da direita sobre o omnetpp.ini. Em Run As->Run Configurations setar Cmdenv em user interface:
Filtrar, selecionar, plotar e simular os resultados.
Para simular em linha de comando:
opp_makemake
make
./MM1v3 -u Cmdenv -c General -g
Onde MM1v3 é o arquivo binário gerado na simulação.
ETAPA 7
Parametrize os tempos de serviço de forma individual (para cada fila). Tente encontrar um valor de tempo de serviço que deixe o tempo do ramo Queue0 - Queue1 menor que o do ramo Queue0 - Queue2.
Aula 14 - Dia 8/05/2019
Objetivos
- Continuação do projeto do splitter
Link para o manual de instalação do Omnet
Aula 15 - Dia 14/05/2019
Objetivos
- Familiarizar o aluno com conceitos da biblioteca INET do Omnet:
- Realização dos Steps de 1 a 5 do Tutorial Wireless
Tutorial Wireless
Step 1 - Dois hosts se comunicando sem fio
- Explicar o arquivo NED e omnetpp.ini
- Mostrar a estrutura do Wireless Node, entrando no inet/src/nodes
- Configuração de Endereços IP e uso do ARP
- Modelo de Tráfego
- Meio Físico
- Interface NIC
- Rodar a simulação e verificar o número de pacotes transmitidos e recebidos
Exercício
- Criar uma configuração adicional no omnetpp.ini:
[Config Wireless01-Ex1]
extends = Wireless01
network = WirelessAd
</syntaxhighlight>
- Criar uma network WirelessAd adicional no WirelessA.ned extendendo a WirelessA. Acrescentar um nodo comunicante hostC com uma aplicação UDP similar a do hostA e com destino ao hostB. No hostB configurar uma aplicação UDP servidora escutando em uma porta adicional. Rodar a comunicação e verificar o número pacotes recebidos confrontando com os transmitidos. Registrar os eventos (evetlog) e observar o diagrama de troca de mensagens.
Step 2 - Animações
Step 3 - Acréscimo de Nodos e redução da distância de comunicação
Step 4 - Rota Estática
Step 5 - Habilitando interferência
Step 6 - Uso do CSMA
Aula 16 - Dia 22/05/2019
Objetivos
- Finalização do assunto de SImulação a Eventos Discretos
- Apresentação das Implementações do Simulador
- Discussão das possíveis modificações para implementar duas filas encadeadas onde a primeira fila alimenta a segunda fila com 10% do tráfego.
AULA 17 - Dia 28/05/2019
- Introdução a Cadeias de Markov
Referências
https://www.dropbox.com/s/c5j4fbgav3uo7pj/CadeiasDeMarkovDiscretas_Parte1.pdf?dl=0
AULA 18 - Dia 29/05/2019
- Introdução a Cadeias de Markov
- REgime TRansitório
- Regime Permanente
Referências
https://www.dropbox.com/s/c5j4fbgav3uo7pj/CadeiasDeMarkovDiscretas_Parte1.pdf?dl=0
AULA 19 - Dia 5/06/2019
Objetivos
- DTMC: Holding Time, Média de primeira transição
- Simulação de DTMC
- Tarefa
Slides Aula
Programa Simulação Cadeia Markov
TAREFA 8 - Simulação de Caddeia de Markov e comparação com resultado teórico de 05/06/2019 às 00h00 a 11/06/2019 às 23h59 Não 0
Segundo discutido em sala e exercício do slide
P = [
0.2 0 0.8 0 0 0 0 0 0 0;
0 0.2 0.3 0.3 0.2 0 0 0 0 0;
0 0 0.1 0 0 0.9 0 0 0 0;
0 0 0 0 0 0 1.0 0 0 0;
0 0 0 0 0 0.3 0.7 0 0 0;
0 0 0 0 0 0 0 0.2 0 0.8;
0 0 0 0 0 0 0 0 0.8 0.2;
1.0 0 0 0 0 0 0 0 0 0;
0 1.0 0 0 0 0 0 0 0 0;
0.2 0.6 0 0 0 0 0 0 0 0.2;
];
AULA 20 =