ADS29009-2019-2
AULA 1 - Dia 30/07/2019
Objetivos
- Apresentação da Disciplina (SIGA A)
- Plano de Ensino (SIGA A)
- Avaliação (SIGA A)
Introdução a ADS
- Que projeto estou fazendo? Como procedo para fazer uma ADS?
Tarefa A1.1
- Pesquisar um artigo sobre ADS em uma área de seu interesse. Analisar um arquivo a luz das etapas e conceitos discutidos nesta semana.
Fazer slides que devem ser postados na data anterior da apresentação. O slide deve apresentar:
- Objetivo da ADS no artigo
- Métricas
- Parâmetros
- Fatores
- Workload
- Técnicas usadas
- Resumo de como são apresentados os dados
- Conclusão Pessoal
APRESENTAÇÃO: Dia 9/8/2019
Material de Referência
AULA 2 - Dia 2/08/2019
Objetivos
- Continuação conceitos de ADS
Material de Referência
AULA 3 - Dia 9/08/2019
Objetivos
- Finalização Introdução ADS
- Apresentação dos Trabalhos
AULA 4 - Dia 13/08/2019
Objetivos
- Introdução a DTMC
Materialde Referência
https://www.dropbox.com/s/oz2dlua2kmc1w2m/CadeiasDeMarkovDiscretas_Parte1.pdf?dl=0
AULA 5 - Dia 16/08/2019
Objetivos
- Continuação DTMC
Material de Referência
https://www.dropbox.com/s/oz2dlua2kmc1w2m/CadeiasDeMarkovDiscretas_Parte1.pdf?dl=0
Links Interessantes
AULA 6 - Dia 23/08/2019
Objetivos
- Continuação DTMC
- Simulação DTMC
Itens a constar da atividade de simulação
- código fonte matlab
- minirelatório com:
- comparação dos resultados das probabilidades em regime estacionário conforme slide;
- resposta as questões do slide
- Uma pdf das transições de primeira passagem para os estados colocados no slide.
Material de Referência
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 7 - Dia 27/08/2019
- Simulação da DTMC (conclusão)
AULA 8 - Dia 30/08/2019
Objetivos
- Aplicações de DTMC: Aloha Puro
- Discussão de Projeto usando os Mindstorms
Slides desta Aula
Aula 9 - Dia 06/09/2019
- Introdução a CTMC
- Projeto de Desempenho sobre o Robô
Material de Referência
Links sobre o EV3
Aula 10 - Dia 10/09/2019
- Instalação de tools C++ no ev3
Usar máquina virtual com Ubuntu 18.04
Fazer conforme
- Toolchain
O make e o gcc devem estar instalados.
https://c4ev3.github.io/ (Lembrar que são ferramentas 32 bits)
sudo apt-get install lib32ncurses5 lib32z1 sudo apt-get install libudev-dev pkg-config wget -c http://www.codesourcery.com/sgpp/lite/arm/portal/package4571/public/arm-none-linux-gnueabi/arm-2009q1-203-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 mkdir CodeSourcery tar -jxvf ~/arm-2009q1-203-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 -C ~/CodeSourcery/ echo export PATH=~/CodeSourcery/arm-2009q1/bin/:$PATH >> ~/.bashrc && . ~/.bashrc
- Uploader (não usei diretamente pois fiz scp para robot@IP_ROBO (password "maker".
git clone --recursive https://github.com/c4ev3/ev3duder
Entrar e compilar usando o make Entrar em EV3-API/API e compilar. EU tive que editar o Makefile para remover a referência ao Windows
- Compilar
arm-none-linux-gnueabi-gcc -I../EV3-API/API -L../EV3-API/API/ alo.c -lev3api
Aula 11 - Dia 13/09/2019
Objetivos
- CTMC - Aplicações: modelagelam da alocação de GTS no IEEE802.15.4
Problema (simplificação do GTS no IEEE 802.15.4
O padrão de rede sem fio IEEE802.15.4 prevê a comunicação sem BEACON (CSMA-CA) e com BEACON, onde parte do frame possui até 7 canais que podem ser alocados sob demanda por um coordenaodor (supor topologia em estrela com coordenador no centro). A alocação é realizada em canal de controle a parte. Construir uma cadeia de Markov em Tempo Contínuo de forma:
(i) a computar a probabilidade de bloqueio. Supor N nodos com número médio de requisições
(ii) como poderia ser computada a vazão esperada do sistema?
(iii) como poderíamos estimar a vazão na parte CSMA-CA (supor comportamento como Slotted Aloha)
(iv) na parte GTS, como poderíamos considerar dois grupos de nodos onde o primeiro grupo pode ocupar os 7 slots e o segundo grupo, com taxa diferente poderia ocupar até dois slots?
Aula 12 - Dia 20/09/2019
- Introdução a Teoria de Filas
- Filas MM1 com buffer ilimitado
Material de Referência
Aula 13 - Dia 24/09/2019
Objteivos
- Desenvolvimento de Projeto de ADS
Visão geral do Software no Mindstorm
Especificação dos Recursos Rest
Especificação das mensagens no socket
O "programa sob teste" se conecta no servidor Flask através de um socket. O programa se comporta como um servidor que recebe comandos atraváes de uma string de tamanho fixo (15 caracteres). A todo comando ele envia uma resposta também de 15 caracteres.
No momento que recebe um comando o programa deve ler o tempo do sistema e ao enviar uma resposta ele deverá ler novamente o tempo e enviá-lo na string de resposta;
Formato da string (ideal seria usar padrão: XML,JSON?). Vantagem de usar XML seria usar uma biblioteca padrão.
Comando;P:par1;P:par2;...;TE:...tempo;TS:tempo
Pontos a verificar:
- o tamanho da string deveria ser aumentada ou flexibilizado?
Especificação do Gerador de Cargas/Monitor
- O gerador de carga deverá ler uma especificação de um arquivo e gerar a carga. Prever identificação do Experimento e da Repetição.
- O monitor deverá ler as respostas e armazená-las devidamente em arquivo.
- Um analisador/visalizador de dados deverá permitir sumarizar dados, gerar intervalo de confiança e mostrar os resultados
Módulo de Processamento Autônomo
- include <stdio.h>
- include <sys/time.h>
//classe baseada no geekforgeeks
class t_duracao {
public:
void iniciar_medicao() {
gettimeofday(&start, NULL);
}
void finalizar_medicao(){
gettimeofday(&end, NULL);
time_taken = (end.tv_sec - start.tv_sec) * 1e6;
time_taken = (time_taken + (end.tv_usec -
start.tv_usec)) * 1e-6;
}
void mostrar_tempo(){
printf("valor de tempo = %lf", time_taken);
}
float retornar_tempo(){
return time_taken;
}
private:
double time_taken;
struct timeval start, end;
} tempo_estimado;
float computar_desloc_x()
{
float d;
d = 10+20*uniforme(); // uniforme retorna entre 0 e 1 - no minimo andará 10cm e no máximo 30 cm
return d;
}
float computar_lateral(float meu_y, float meu_desloc)
{
float lat;
lat = seno (0.042*meu_desloc) * 50; /* amplitude máxima 50 cm
return lat-meu_y;
}
main()
{
receive(max_x,max_y);
tempo_estimado.iniciar_medicao();
x=0; //valor absoluto do movimento na direção x
desloc_x=0;
y=0; //valor absoluto do movimento na direção y
desloc_y=0;
while (x<max_x) {
//computar movimento para frente
desloc_x=computar_desloc_x();
x = desloc_x + x;
//andar para frente
movimento_avante(desloc);
//computar movimento lateral
desloc_y=computar_lateral(y, x);
y=y+desloc_y;
movimento_lateral(desloc_y);
rotacionar_frente();
}
finaliza_movimento();
tempo_estimado.finalizar_medicao();
send_annswer(tempo_estimado.retornar_tempo());
}
</syntaxhighlight>
<>
uniforme()*10+10;
<>
Referências
Aula 14 - Dia 27/09/2019
Objetivos
- Revisão Fila M/M/1
- Fila M/M/1/c (c servidores)
Material de Referência para esta aula
Aula 15 - Dia 04/10/2019
Objetivos
- Revisão Fila M/M/n
- Fila M/M/1/K
Material de Referência para esta aula
https://www.dropbox.com/s/jycdd2dzqqsxb5g/FilaMM1_CapacidadeLimitada.pdf?dl=0
AULA 16 - Dia 08/10/2019
Objetivos
- Aula antecipada para tratar o experimento do rob
- Geração de Números Randômicos na Simulação
Material de Referência
AULA 17 - Dia 11/10/2019
Objetivos
- finalização da classe de geração randômica de números;
- construção do módulo autônomo do robô usando geração randômica.
Links interessantes
AULA 18 - Dia 11/10/2019
Objetivos
- PARTE 1
- Introdução a Simulação a Eventos Discretos
- Exemplo de simulação e estatística de uma fila MM1
- PARTE 2
- Preparação do robô para Feira de Ciências e Tecnologia
Material de referência
AULA 19 - Dia 11/10/2019
PALESTRA - IOT - IPTV
AULA 20 - Dia 25/10/2019
Objetivos
- Estudo de uma Implementação de um Simulador a Eventos Discretos;
Material de Referência
- Ver Projeto Apache
- Proposição de Exercício: simulação de uma rede de filas;
- 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;
}
Modelo de Simulação a ser implementado - Atividade A2.1
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. 50% do tráfego gerado por queue0 é reconduzido para queue1 e 30% para queue2 e 20 % saem do sistema. Computar o tempo médio no sistema das requisições em cada ramo da rede (queue1 e queue2).
AULA 21 - Dia 29/10/2019
Objetivos
- Estudo de uma Implementação de um Simulador a Eventos Discretos;
- 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)
AULA 22 - Dia 1/11/2019
Objetivos
- Continuação exemplo tic-toc
- Fila MM1 no omnet
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 {[General]
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>
AULA 23 - Dia 5/11/2019
Objetivos
- Exemplo de Rede de Filas no Omnet
- ExperimentoxMediçãoXRepetição;
- Análise de resultados da simulação usando o Omnet
// *** 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;
}
simple Splitter
{
parameters:
volatile double prob_out0; // sec
volatile double prob_out1; // sec
@display("i=block/sink");
gates:
input in;
output out[2];
}
network MM1Rede1
{
submodules:
gen: Generator {
@display("p=265,212");
}
queue0: Queue {
@display("p=265,118");
}
queue1: Queue {
@display("p=110,58");
}
queue2: Queue {
@display("p=110,173");
}
splitter: Splitter {
@display("p=193,118");
}
sink1: Sink {
@display("p=49,58");
}
sink2: Sink {
@display("p=49,173");
}
connections:
gen.out --> queue0.in;
queue0.out --> splitter.in;
splitter.out[0] --> queue1.in;
splitter.out[1] --> queue2.in;
queue1.out --> sink1.in;
queue2.out --> sink2.in;
}
network MM1Rede2
{
submodules:
gen: Generator {
@display("p=265,212");
}
queue0: Queue {
@display("p=265,118");
}
queue1: Queue {
@display("p=110,58");
}
queue2: Queue {
@display("p=110,173");
}
queue3: Queue {
@display("p=102,243");
}
splitter: Splitter {
@display("p=193,118");
}
sink1: Sink {
@display("p=49,58");
}
sink2: Sink {
@display("p=38,243");
}
connections:
gen.out --> queue0.in;
queue0.out --> splitter.in;
splitter.out[0] --> queue1.in;
splitter.out[1] --> queue2.in;
queue1.out --> sink1.in;
queue2.out --> queue3.in;
queue3.out --> sink2.in;
}
</syntaxhighlight>
- omnetpp.ini
[General]
sim-time-limit = 100s
- .gen.interArrivalTime=exponential(1)
- .queue0.serviceTime=exponential(0.2)
- .queue1.serviceTime=exponential(0.2)
- .queue2.serviceTime=exponential(0.8)
- .splitter.prob_out0 = 0.5
- .splitter.prob_out1 = 0.3
repeat=3
[Config Experimento1]
network = MM1Rede1
[Config Experimento2]
network = MM1Rede2
- .gen.interArrivalTime=exponential(${1,2})
- .queue3.serviceTime=exponential(0.8)
</syntaxhighlight>
splitter.cc
/*
* splitter.cc
*
* Created on: Nov 5, 2019
* Author: eraldo
*/
/*** queue.cc ***/
- include <string.h>
- include <omnetpp.h>
using namespace omnetpp;
class Splitter : public cSimpleModule {
private:
// local variable
cQueue buffer;
cMessage *endServiceEvent;
simtime_t service_time;
public:
// constructor
Splitter(); // constructor
virtual ~Splitter(); // destructor
protected:
virtual void initialize();
virtual void finish();
virtual void handleMessage(cMessage *msg);
};
Define_Module(Splitter);
Splitter::Splitter() {
}
Splitter::~Splitter() {
}
void Splitter::initialize() {
endServiceEvent=new cMessage("endService");
}
void Splitter::finish() {}
void Splitter::handleMessage(cMessage *msg) {
double unif_rand = uniform(0, 1);
if ( unif_rand < par("prob_out0").doubleValue()) {
send(msg,"out",0);
EV << "Encaminhando queue1\n";
} else if ( unif_rand > par("prob_out0").doubleValue() && unif_rand < (par("prob_out0").doubleValue()+par("prob_out0").doubleValue())) {
send(msg,"out",1);
EV << "Encaminhando queue2\n";
} else
delete msg;
}
</syntaxhighlight>
AULA 23 - Dia 5/11/2019
Objetivos
- Ainda Exemplo de Rede de Filas no Omnet
- Análise de resultados da simulação usando o Omnet
- Intervalo de Confiança no Omnet
- Instalação do inet
- Início do Tutorial Wireless
Manuais Omnet
AULA 24 - Dia 8/11/2019
AULA 25 - Dia 19/11/2019
- Curso Hitachi
AULA 26 - Dia 22/11/2019
==Variação 1
- Ainda INET: Tutorial Wireless
- Modificar o Step 10 para variar potência de transmissão para 0.6, 0.9 e 1.2mW
- Verificar se existe impacto no EndToEndDelay
AULA 27 - Dia 26/11/2019
- Confiança Estatística:
- Explorando os ShowCases no Omnet
AULA 28 - Dia 29/11/2019
- Explorando os ShowCases no Omnet
AULA 29 - Dia 3/12/2019
- Medição Ativa e Passiva em Redes
- Projeto de Experimento de Medição em Redes Sem Fio
AULA 30 - Dia 6/12/2019
- Finalização do Projeto de Medição do Robô
AULA 31 - Dia 13/12/2019
- Finalização do Projeto de Medição do Robô
Livros sobre ADS
Links Interessantes