A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Curso de NS Rainer R. P. Couto

Apresentações semelhantes


Apresentação em tema: "Curso de NS Rainer R. P. Couto"— Transcrição da apresentação:

1 Curso de NS Rainer R. P. Couto

2 Sumário Arquitetura do Software Hierarquia de Objetos Principais Classes em OTcl e C++ Escalonador Temporizadores – Timers Geração de números aleatórios

3 Arquitetura do software

4 Arquitetura do Software Tcl script language Fracamente tipada Configuração C/C++ system language Fortemente tipada Core programming OTcl Tcl orientado a objetos TclCL (TclCLass) Tcl com suporte a object oriented split-level programming Tcl OTclTclCL ns-2 Escalonador de eventos Componentes de rede C/C++

5 Estrutura Interna Arquitetura do NS Orientado a objetos Escrito em C++ Interpretador Tcl como frontend Arquitetura do NS Duas hierarquias de objetos Hierarquia C++ (compilada) Hierarquia OTcl (interpretada) Correspodência um para um pela perspectiva do usuário C++OTcl Pure C++ objects Pure OTcl objects C++/OTcl split objects ns

6 Split-level programming Por que duas linguagens? C++: execução rápida / alteração complexa Processamento de cada pacote, alteração de comportamento de objetos existentes em C++ (dado), estruturas e algotirmos complexos, código com alterações infreqüentes OTcl: alteração simples / execução lenta Configuração, setup, escalonamento de eventos periódicos e manipulação simples de objetos (controle), código com alterações freqüentes Tclcl provê a forma de unir as duas linguagens + Compromisso entre composabilidade e velocidade – Aprendizado e correção de erros

7 O Mérito do OTcl Granularidade do código/script pode ser ajustada para compensar extensibilidade por performance. Tamanho do programa complexidade C/C++ OTcl grande pequeno split objects Instructions/Statement None Strong Degree of Typing Assembly C++ C Java Tcl/Perl Visual Basic John Ousterhout. Scripting: Higher-level programming for the 21st century IEEE Computer, 1998.

8 Principais classes da programação C++/OTcl bind(): realiza o link dos valores das variáveis compartilhadas entre C++ e OTcl TclObject command(): realiza o link entre métodos chamados no OTcl e implementados em C++ TclClass Cria e inicializa TclObjects Tcl Métodos C++ para acessar o interpretador Tcl TclCommand Comandos globais EmbeddedTcl Inicialização do script ns Raiz da hierarquia de objetos do ns-2

9 Principais classes da programação C++/OTcl bind(): realiza o link dos valores das variáveis compartilhadas entre C++ e OTcl TclObject command(): realiza o link entre métodos chamados no OTcl e implementados em C++ TclClass Cria e inicializa TclObjects Tcl Métodos C++ para acessar o interpretador Tcl TclCommand Comandos globais EmbeddedTcl Inicialização do script ns Raiz da hierarquia de objetos do ns-2

10 TclObject: Hierarquia e Shadowing TclObject Agent Agent/TCP Agent/TCP OTcl Objeto shadow _o123 Objeto Agent/TCP C++ *tcp TclObject Agent TcpAgent Hierarquia de classes OTcl Hierarquia de classes C++

11 TclObject::bind() Une variáveis membras de classes no C++ a variáveis no OTcl Duas referências para um mesmo objeto C++ TcpAgent::TcpAgent() { bind(window_, &wnd_); bind_bw(taxa_", &taxa_); } bind_time(), bind_bool(), bind_bw() OTcl set tcp [new Agent/TCP] $tcp set window_ 200 $tcp set taxa_ 1.5Mb

12 Inicialização de variáveis do bind Inicialização através de variáveis de classe do OTcl Agent/TCP set window_ 50 Faça toda a inicialização de variáveis de bind em ~ns/tcl/lib/ns-default.tcl Caso contrário, um aviso de alerta será mostrado quando o objeto shadow for criado

13 Implementação de variáveis de bind Classe InstVar Um objeto por variável de bind – caro! InstVarInt, InstVarReal,... Criados por TclObject::bind() Cria instância da variável na pilha OTcl Habilita trap de escrita/leitura para variável OTcl Conecta à variável C++ na ocorrência de traps

14 TclObject::command() Implementa métodos do OTcl em C++ Trap point: Método cmd{} em OTcl Após chamado, cmd{} envia todos seus argumentos para TclObject::command()

15 TclObject::command() OTcl set tcp [new Agent/TCP] $tcp advance 10 C++ int TcpAgent::command(int argc, const char*const* argv) { if (argc == 3) { if (strcmp(argv[1], advance) == 0) { int newseq = atoi(argv[2]); …… return(TCL_OK); } return (Agent::command(argc, argv); }

16 TclObject::command() $tcp send TclObject::unknown{}$tcp cmd send procedimento não existe TcpAgent::command() implementa send? Chama o método do pai: return Agent::command() Processa e retorna Sim Não OTcl space C++ space

17 TclObject: Criação e Remoção Procedimentos globais: new{}, delete{} Exemplo set tcp [new Agent/TCP] … delete $tcp

18 TclObject: Criação e Remoção C++ OTcl chama cons_ trutor do pai construtor Agent/TCP construtor pai (Agent) chama cons_ trutor do pai construtor TclObject cria objeto C++ construtor AgentTCP chama cons_ trutor do pai chama cons_ trutor do pai construtor pai (Agent) Não faz nada, retorna construtor TclObject (C++) realiza binds e retorna realiza binds e retorna cria objeto shadow OTcl completa inicialização completa inicialização Qual objeto C++ deve ser criado? – TclClass

19 Principais classes da programação C++/OTcl TclClass Cria e inicializa TclObjects Tcl Métodos C++ para acessar o interpretador Tcl TclCommand Comandos globais EmbeddedTcl Inicialização do script ns bind(): realiza o link dos valores das variáveis compartilhadas entre C++ e OTcl TclObject command(): realiza o link entre métodos chamados no OTcl e implementados em C++ Raiz da hierarquia de objetos do ns-2

20 TclClass TclObject Agent Agent/TCP TclObject Agent TcpAgent NsObject ?? OTcl C++ Static class TcpClass : public TclClass { public: TcpClass() : TclClass(Agent/TCP) {} TclObject* create(int, const char*const*) { return (new TcpAgent()); } } class_tcp; Static class TcpClass : public TclClass { public: TcpClass() : TclClass(Agent/TCP) {} TclObject* create(int, const char*const*) { return (new TcpAgent()); } } class_tcp;

21 TclClass: Mecanismo Inicialização durante o startup da execução SplitObject::register{} Cria e registra Classe OTcl Agent/TCP TclClass::init() para cada TclClass definida estaticamente TcpClass::bind() e.g. Agent/TCP::create-shadow{} TclClass::create_shadow()

22 Principais classes da programação C++/OTcl bind(): realiza o link dos valores das variáveis compartilhadas entre C++ e OTcl TclObject command(): realiza o link entre métodos chamados no OTcl e implementados em C++ TclClass Cria e inicializa TclObjects Tcl Métodos C++ para acessar o interpretador Tcl TclCommand Comandos globais EmbeddedTcl Inicialização do script ns Raiz da hierarquia de objetos do ns-2

23 Classe Tcl Classe que possui a referência para o interpretador Tcl Uso Chamar procedimentos em OTcl Obter resultados de expressões em OTcl Passar um resultado para o OTcl Retornar um código de sucesso/falha para o Otcl Armazenar e realizar procuras por referências a TclObjects

24 Obtendo uma referência para o interpretador Uma única referência ao intepretador está declarado no arquivo Tcl.cc (dentro do diretório tclclXXX) como um membro estático da classe Tcl. Antes de acessar qualquer método do intepretador, devemos obter essa referência. Comando Tcl& tcl = Tcl::instance();

25 Passandos comandos para o interpretador Tcl& tcl = Tcl::instance(); char wrk[128]; strcpy(wrk, "Simulator set NumberInterfaces_ 1"); tcl.eval(wrk); sprintf(tcl.buffer(), "Agent/SRM set requestFunction_ %s", "Fixed"); tcl.eval(); tcl.evalc("puts stdout \hello world\"); tcl.evalf("%s request %d %d", name_, sender, msgid); Tcl::eval(char *): passa string para o intepretador Tcl::evalc(const char *): preserva o string de entrada Tcl::eval(): supõe que o comando já está em tcl.buffer Tcl::evalf(char *, par1, par2,...): printf like Exemplo:

26 Coletando resultados Quanto o intepretador chama um comando em C++, espera-se um resultado na variável interna result. Comando: tcl.resultf() Similarmente, quando o C++ faz uma chamada a um método do interpretador, o resultado pode ser acessado através da mesma variável. Comando: tcl.result()

27 Exemplo de métodos de Tcl Tcl& tcl = Tcl::instance(); if (argc == 2) { if (strcmp(argv[1], now) == 0) { tcl.resultf(%g, clock()); return TCL_OK; } tcl.error(command not found); return TCL_ERROR; } else if (argc == 3) { tcl.eval(argv[2]); clock_ = atof(tcl.result()); return TCL_OK; }

28 Funções de Hash da classe Tcl O intepretador possui uma tabela hash com entradas para todos TclObjects criados durante a simulação. void Tcl::enter(TclObject* o) Utilizado para criar uma nova entrada para o novo TclObject TclObject* Tcl::lookup(const char* name) Utilizado para fazer uma procura por um TclObject

29 Principais classes da programação C++/OTcl bind(): realiza o link dos valores das variáveis compartilhadas entre C++ e OTcl TclObject command(): realiza o link entre métodos chamados no OTcl e implementados em C++ TclClass Cria e inicializa TclObjects Tcl Métodos C++ para acessar o interpretador Tcl TclCommand Comandos globais EmbeddedTcl Inicialização do script ns Raiz da hierarquia de objetos do ns-2

30 Class TclCommand Implementação em C++ de comandos globais em OTcl class RandomCommand : public TclCommand { public: RandomCommand() : TclCommand("ns-random") {} virtual int command(int argc, const char*const* argv); }; int RandomCommand::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 1) {... } Inicializar um novo objeto – new RandomCommand() – em misc.cc::init_misc

31 Principais classes da programação C++/OTcl bind(): realiza o link dos valores das variáveis compartilhadas entre C++ e OTcl TclObject command(): realiza o link entre métodos chamados no OTcl e implementados em C++ TclClass Cria e inicializa TclObjects Tcl Métodos C++ para acessar o interpretador Tcl TclCommand Comandos globais EmbeddedTcl Inicialização do script ns Raiz da hierarquia de objetos do ns-2

32 EmbeddedTcl Carrega OTcl scripts durante a inicialização do ns ~ns/tcl/lib/ns-lib.tcl: Carrega recursivamente ~ns/tcl/lib/ns-lib.tcl: source ns-autoconf.tcl source ns-address.tcl source ns-node.tcl Carrega tudo em um único vetor de caracteres em C++ Executa esse string durante a inicialização

33 EmbeddedTcl Como funciona tcl2c++ tcl2c++ : provido pelo TclCL, converte tcl scripts em vetores estáticos de caracteres em C++ Makefile.in: tclsh8.0 bin/tcl-expand.tcl tcl/lib/ns-lib.tcl | tcl2c++ et_ns_lib > gen/ns_tcl.cc

34 Resumo TclObject Classe raiz das hierarquias compilada (C++) e interpretada (OTcl) Acesso transparente (chamadas de procedimento e acesso de variáveis) entre OTcl e C++ TclClass Mecanismo que torna possível TclObject Tcl Primitivas para acessar o interpretador Tcl

35 Escalonador

36 Utilizando-se o NS... Criação do simulador Escalonador de eventos [Habilitação do tracing] Criação da rede Configuração do roteamento... set ns [new Simulator] # [Turn on tracing] # Create topology # Setup packet loss, link dynamics # Create routing agents # Create: # - multicast groups # - protocol agents # - application and/or setup traffic sources # Post-processing procs # Start simulation

37 Escalonador O que é o escalonador? Controlador de eventos dentro do simulador Arquivos correspondentes: tcl/lib/ns-lib.tcl (class Simulator) common/scheduler(.h,.cc) (class Scheduler) heap.h (class Heap)

38 Modelo do escalonador Modela mundo como eventos Simulador possui uma lista de eventos Processo: pega o primeiro evento da lista, executa até estar completo Cada evento acontece em um determinado instante do tempo virtual (tempo simulado), mas pode levar um tempo real arbitrátio Implementação muito simples uma thread de controle => não precisamos nos preocupar com condições de corrida ou locking (bem simples)

39 Escalonador de Eventos time_, uid_, next_, handler_ handler_ -> handle() time_, uid_, next_, handler_ insert head_ -> class Event { public: Event* next_; /* event list */ Handler* handler_; /* handler to call when event ready */ double time_; /* time at which event is ready */ scheduler_uid_t uid_; /* unique ID */ Event() : time_(0), uid_(0) {} }; class Handler { public: virtual void handle(Event* event) = 0; };

40 Modelo do escalonador Considere dois nodos em uma rede Ethernet AB Modelo de filas simplificado: t=1A coloca um pacote na fila da LAN t=1.01LAN retira o pacote da fila e LAN e dispara um evento de recepção em B Modelo CSMA/CD detalhado: t=1.0A envia pacote para NIC; NIC de A inicia carrier sense t=1.005NIC de A conclui cs, inicia tx t=1.006NIC de B começa a recepção do pacote t=1.01NIC de B conclui recepção do pacote NIC de B passa pacote para agente/aplicação

41 Criação do escalonador Criação do simulador de eventos set ns [new Simulator] Escalonamento de eventos $ns at : qualquer comando legítimo no ns/tcl Ex: $ns at 5.0 finish Início da execução do escalonador $ns run Escalonador Calendar: default Escalonador Real-time Sincroniza com tempo real Emulação de redes set ns_ [new Simulator] $ns_ use-scheduler Heap $ns_ at $self halt

42 Simulador - métodos Simulator instproc init args { $self instvar useasim_ $self instvar useasim_..._..._ set slinks_(0:0) 0 set slinks_(0:0) $self create_packetformat $self create_packetformat $self use-scheduler Calendar $self use-scheduler Calendar #$self use-scheduler List #$self use-scheduler List......} Simulator instproc use-scheduler type { $self instvar scheduler_ $self instvar scheduler_ if [info exists scheduler_] { if [info exists scheduler_] { if { [$scheduler_ info class] == if { [$scheduler_ info class] == "Scheduler/$type" } { "Scheduler/$type" } { return return } else { } else { delete $scheduler_ delete $scheduler_ } } set scheduler_ [new Scheduler/$type] set scheduler_ [new Scheduler/$type] $scheduler_ now $scheduler_ now} Simulator instproc at args { $self instvar scheduler_ $self instvar scheduler_ return [eval $scheduler_ at $args] return [eval $scheduler_ at $args]} Simulator instproc run {} {... return [$scheduler_ run] return [$scheduler_ run]}

43 Escalonador - Tipos ListScheduler Lista simples O(N) HeapScheduler Baseado em um Heap O(logN) CalendarScheduler Baseado em Hash O(1) SplayScheduler RealTimerScheduler

44 Modos do escalonador Modo interativo arara:/ns-> ns % set ns [new Simulator] _o3 % $ns at 1 puts \Hello World!\ 1 % $ns at 1.5 exit 2 % $ns run Hello World! arara:/ns-> Modo batch: simple.tcl set ns [new Simulator] $ns at 1 puts \Hello World!\ $ns at 1.5 exit $ns run arara:/ns-> ns simple.tcl Hello World! arara:/ns->

45 Temporizadores – Timers

46 O que é um temporizador? Um temporizador (timer) é um elemento que dispara um determinado evento e que pode ser programado Usado principalmente em agentes, mas pode ser utilizado em outros objetos Ex: retransmissão no agente TCP Temporizadores podem ser implementados em C++ ou em OTcl. São baseados em uma classe abstrata definida em timer- handler.h Em OTcl um temporizador pode ser criado derivando a classe definida em tcl/mcast/timer.tcl.

47 Temporizadores – Funções e atributos A classe abstrata TimerHandler contém os seguintes métodos públicos disponíveis: void sched(double delay) Escalona um temporizador para disparar em delay segundos void resched(double delay) Re-escalona o temporizador (similar ao sched, mas o temporizador pode estar pendente) void cancel() Cancela um temporizador pendente int status() Retorna o status do temporizador (TIMER_IDLE, TIMER_PENDING, ou TIMER_HANDLING)

48 Temporizadores – Funções e atributos A classe abstrata TimerHandler contém os seguintes métodos protegidos disponíveis: virtual void expire (Event* e) = 0 Este método deve ser preenchido com o código a ser executado no instante de disparo do evento virtual void handle (Event* e) Consome um evento; faz um chamada para expire() e atribui o valor adequado a status_ int status_ Variável que mantém o atual status do temporizador Event event_ Evento que deve ser consumido

49 Temporizadores – Funções e atributos O método virtual expire() deve ser defindo na classe derivada da classe abstrata Dois métodos privados inline são definidos: inline void _sched(double delay) { (void)Scheduler::instance().schedule(this, &event_, delay); } inline void _cancel() { (void)Scheduler::instance().cancel(&event_); } Esses códigos utilizam diretamente métodos do escalonador.

50 Definindo um Temporizador Temporizadores criados em C++ não são diretamente acessíveis através do Otcl. Geralmente um temporizador será uma classe amiga da classe agente onde se encontra ou expire() chamará um método público deste agente. class MyTimer : public TimerHandler { public: MyTimer(MyAgentClass *a) : TimerHandler() { a_ = a; } virtual double expire(Event *e); protected: MyAgentClass *a_; }; double MyTimer::expire(Event *e) { // executa a função // Opção 1: // =\> não re-escalona o temporizador // Opção 2: // =\> re-escalona temporizador para // =\> disparar novamente em delay // =\> segundos }

51 Exemplo – Retransmissão no TCP Existem três temporizadores declarados no agente TCP Tahoe definido em tcp.cc: rtx_timer_; Temporizador de retransmissão delsnd_timer_; Atrasa o envio do pacote por um pequeno tempo aleatório, de forma a evitar efeitos cíclicos burstsnd_timer_; Auxilia o TCP no envio de uma grande janela de tranmissão dividida em várias partes menores Em tcp.h existem três classes de temporizadores definidas: class RtxTimer class DelSndTimer class BurstSndTimer class RtxTimer : public TimerHandler { public: RtxTimer(TcpAgent *a) : TimerHandler() { a_ = a; } protected: virtual void expire(Event *e); TcpAgent *a_; };

52 Exemplo – Retransmissão no TCP TcpAgent::TcpAgent() : Agent(PT_TCP), rtt_active_(0), rtt_seq_(-1),... rtx_timer_(this), delsnd_timer_(this), burstsnd_timer_(this) {... } void TcpAgent::set_rtx_timer() { rtx_timer_.resched(rtt_timeout()); } void TcpAgent::newtimer (Packet* pkt) { hdr_tcp *tcph = (hdr_tcp*) pkt->access( off_tcp_ ); if ( t_seqno_ > tcph->seqno() ) set_rtx_timer(); else if ( rtx_timer_.status() == TIMER_PENDING ) rtx_timer_.cancel(); } void TcpAgent::timeout( int tno ) {... } void RtxTimer::expire( Event *e ) { a_->timeout( TCP_TIMER_RTX ); }

53 Temporizador em OTcl Diferença básica: ao contrário da implementação em C++, onde uma chamada a sched() para um temporizador pendente causa um abort(), sched e resched em OTcl possuem a mesma funcionalidade Nenhum estado é mantido para o temporizador As seguintes funções são definidas para o temporizador: $self sched $delay # programa o temporizador para $delay seg.; $self resched $delay # o memo que "$self sched $delay" ; $self cancel # cancela o temporizador (não há callback); $self destroy # o mesmo que "$self cancel"; $self expire # faz uma chamada a "$self timeout" imediatamente; timeout deve estar definida na subclasse /tcl/mcast/timer.tcl:... Timer instproc sched delay { $self instvar ns_ $self instvar id_ $self cancel set id_ [$ns_ after $delay "$self timeout"] }...

54 Geração de Números Aleatórios

55 Suporte Matemático. O NS possui uma pequena coleção de funções matemáticas usadas para implementar funções geradoras de números aleatórios e cálculos de integrais. Os procedimentos podem ser encontrados nos seguintes arquivos: tools/rng.{cc, h}. tools/random.{cc, h}. tools/ranvar.{cc, h}. tools/pareto.{cc, h}. tools/expoo.{cc, h}. tools/integrator.{cc, h}. tcl/lib/ns-random.tcl.

56 Geração de números aleatórios A classe RNG possui a implementação de um gerador recursivo- múltiplo-combinado de números aleatórios (combined multiple recursive random number generator), ou MRG32k3a, proposto por L'Ecuyer (para versões 2.1b9 e posteriores). Versões anteriores utilizam o minimal standard multiplicative linear congruential generator, proposto por Park and Miller O gerador MRG32k3a provê 1,8x10 19 streams independentes de números aleatórios, cada streams sendo composto por 2,3x10 15 substreams. Cada substream possui um período de 7,6x10 22 O período do gerador é de 3,1x10 57 Pierre L'Ecuyer. Good parameters and implementations for combined multiple recursive random number generators. Operations Research, 1999 S.K. Park and R.W. Miller. Random number generation: Good ones are hard to find. Communications of the ACM, 1988.

57 Geração de números aleatórios Um gerador RNG default é criado no início da simulação (defaultRNG). Se múltiplas variáveis aleatórias são utilizadas durante uma simulação, cada variável deve utilizar um objeto RNG distinto. Quando uma nova variável RNG é criada, à sua semente é atribuído um valor de modo a gerar o próximo stream independente de números aleatórios. A implementação permite um número máximo de 1,8x10 19 var. aleatórias. Geralmente são necessárias várias réplicas de um mesmo experimento (análise estatística) Para cada réplica, um substream diferente deve ser utilizado para garantir que as seqüências de números aleatórios sejam independentes. Esse processo limita o número de réplicas possíveis em, no máximo, 2,3x Pierre L'Ecuyer, Richard Simard, E. Jack Chen, and W. David Kelton. An object-oriented random number package with many long streams and substreams. Operations Research, E também em: tools/rng.h tools/rng.cc

58 Semente Semente default de defaultRNG: Somente a semente de defaultRNG necessita ser inicializada Cada RNG é inicializado de modo a produzir uma seqüência independente de números. A semente pode ser inicializada com qualquer valor entre 1 e MAXINT ( ). Para obter comportamento não-determinístico, basta inicializar a semente para 0. A nova semente é baseada na hora corrente e em um contador. Não deve ser usado para produzir uma seqüência independente de dados, já que não há garantia que as seqüências não irão se sobrepor. A única forma de garantir que duas seqüências não irão se sobrepor é utilizar substreams.

59 Exemplo 1 - script # Usage: ns rng-test.tcl [replication number] if {$argc > 1} { puts "Usage: ns rng-test.tcl \[replication number\]" exit } set run 1 if { $argc == 1 } { set run [lindex $argv 0] } if { $run < 1 } { set run 1 } $sizeRNG next-substream } # seed the default RNG global defaultRNG $defaultRNG seed 9999 # create the RNGs and set them to the correct substream set arrivalRNG [new RNG] set sizeRNG [new RNG] for {set j 1} {$j < $run} {incr j} { $arrivalRNG next-substream # arrival_ is a exponential random variable describing the time # between consecutive packet arrivals set arrival_ [new RandomVariable/Exponential] $arrival_ set avg_ 5 $arrival_ use-rng $arrivalRNG # size_ is a uniform random variable describing packet sizes set size_ [new RandomVariable/Uniform] $size_ set min_ 100 $size_ set max_ 5000 $size_ use-rng $sizeRNG # print the first 5 arrival times and sizes for {set j 0} {$j < 5} {incr j} { puts [ format "%-8.3f %-4d" [ $arrival_ value ] \ [expr round([$size_ value])]] }

60 Exemplo 1 - script # Usage: ns rng-test.tcl [replication number] if {$argc > 1} { puts "Usage: ns rng-test.tcl \[replication number\]" exit } set run 1 if { $argc == 1 } { set run [lindex $argv 0] } if { $run < 1 } { set run 1 } # seed the default RNG global defaultRNG $defaultRNG seed 9999 $sizeRNG next-substream } # create the RNGs and set them to the correct substream set arrivalRNG [new RNG] set sizeRNG [new RNG] for {set j 1} {$j < $run} {incr j} { $arrivalRNG next-substream # arrival_ is a exponential random variable describing the time # between consecutive packet arrivals set arrival_ [new RandomVariable/Exponential] $arrival_ set avg_ 5 $arrival_ use-rng $arrivalRNG # size_ is a uniform random variable describing packet sizes set size_ [new RandomVariable/Uniform] $size_ set min_ 100 $size_ set max_ 5000 $size_ use-rng $sizeRNG # print the first 5 arrival times and sizes for {set j 0} {$j < 5} {incr j} { puts [ format "%-8.3f %-4d" [ $arrival_ value ] \ [expr round([$size_ value])]] }

61 Exemplo - saída % ns rng-test.tcl % ns rng-test.tcl

62 Comandos OTcl Os seguintes comandos do RNG podem ser acessados através do OTcl e se encontram implementados em tools/rng.cc: seed : atribui o parâmetro à raiz do gerador. O valor 0 indica uma raiz baseada na hora corrente e em um contador next-random: retorna próximo número aleatório seed: retorna o valor da raiz next-substream: avança para o próximo reset-start-substream: reinicia o substream para o início da seqüência de números aleatórios normal : retorna um número aleatório de uma distribuição normal segundo os parâmetros de entrada lognormal : retorna um número aleatório de uma distribuição lognormal segundo os parâmetros de entrada.

63 Comandos OTcl Os seguintes comandos do RNG podem ser acessados através do OTcl e se encontram implementados em tcl/lib/ns-random.tcl: exponential : retorna um número aleatório retirado de uma distribuição exponencial segundo o parâmetro de entrada uniform : retorna um inteiro retirado de uma distribuição uniforme no intervalo [a, b] integer : retorna um inteiro retirado de uma distribuição uniforme no intervalo [0, k-1]

64 Exemplo 2 - script # Usage: ns rng-test2.tcl [replication number] if { $argc > 1 } { puts "Usage: ns rng-test2.tcl \[replication number\]" exit } set run 1 if { $argc == 1 } { set run [lindex $argv 0] } if { $run < 1 } { set run 1 } # the default RNG is seeded with # create the RNGs and set them to the correct substream set arrivalRNG [new RNG] set sizeRNG [new RNG] for { set j 1 } { $j < $run } { incr j } { $arrivalRNG next-substream $sizeRNG next-substream } # print the first 5 arrival times and sizes for { set j 0 } { $j < 5 } { incr j } { puts [format "%-8.3f %-4d" [$arrivalRNG lognormal 5 0.1] \ [expr round([$sizeRNG normal ])]] } Saída % ns rng-test2.tcl Saída % ns rng-test2.tcl

65 Comandos C++ Métodos da classe RNG O gerador de números aleatórios está implementado na classe RNGImplementation dentro de tools/rng(.h,.cc). Note: A classe Random em tools/random.h é uma interface para a classe RNG (compatibilidade com versões anteriores) Classe RNGImplementation: void set_seed (long seed): igual a OTcl long seed (void): retorna o valor da semente long next (void): próximo número entre [0,MAXINT] double next_double (void) próximo número entre [0,1] void reset_start_substream (void): reinicia substream void reset_next_substream (void): próximo substream

66 Comandos C++ Métodos da classe RNG Classe RNGImplementation: int uniform (int k): retorna inteiro da dist. uniforme entre [0,k-1] double uniform (double r): dist. uniforme entre [0, r] double uniform (double a, double b): dist. uniforme entre [a,b] double exponential (void): dist. exponencial com valor médio 1.0 double exponential (double k): dist. exponencial com valor médio k double normal (double avg, double std): dist. normal com média e desvio padrões dados double lognormal (double avg, double std): dist. lognormal com média e desvio padrões dados

67 Exemplo - código /* create new RNGs */ RNG arrival (23456); RNG size; Saída /* set the RNGs to the appropriate substream */ for (int i = 1; i < 3; i++) { arrival.reset_next_substream(); size.reset_next_substream(); } /* print the first 5 arrival times and sizes */ for (int j = 0; j < 5; j++) { printf ("%-8.3f %-4d\n", arrival.lognormal(5, 0.1), int(size.normal(500, 10))); }

68 Variáveis Aleatórias A classe RandomVariable provê uma abstração das funcionalidades do gerador de números aleatórios e da seqüência de números gerados. Arquivos: tools/ranvar(.h,.cc) class RandomVariable : public TclObject { public: virtual double value() = 0; int command(int argc, const char*const* argv); RandomVariable(); protected: RNG* rng_; }; Classes que derivam dessa classe abstrata implementam uma distribuição específica. Cada distribuição é parametrizada com os respectivos valores. O método virtual value é utilizado para retornar um número que segue a distribuição implementada.

69 Variáveis Aleatórias As distribuições implementadas na versão atual e seus parâmetros são: UniformRandomVariable: min_, max_ ExponentialRandomVariable: avg_ ParetoRandomVariable: avg_, shape_ ParetoIIRandomVariable: avg_, shape_ ConstantRandomVariable: val_ HyperExponentialRandomVariable: avg_, cov_ NormalRandomVariable: avg_, std_ LogNormalRandomVariable: avg_, std_

70 Variáveis Aleatórias A classe RandomVariable está disponível em OTcl. Exemplo: criar uma variável randômica que gera números aleatórios uniformemente distribuídos no intervalor [10, 20] set u [new RandomVariable/Uniform] $u set min_ 10 $u set max_ 20 $u value Por default, um objeto RandomVariable utiliza o RNG default do NS. Para associar um novo RNG à variável deve-se utilizar o método use-rng. set rng [new RNG] $rng seed 0 set e [new RandomVariable/Exponential] $e use-rng $rng

71 Integrais Ns possui uma classe para cálculos de integrais nos arquivos tools/integrator(.h,.cc) Aproximação da integral contínua através de somas discretas class Integrator : public TclObject { public: Integrator(); void set(double x, double y); void newPoint(double x, double y); int command(int argc, const char*const* argv); protected: double lastx_; double lasty_; double sum_; };


Carregar ppt "Curso de NS Rainer R. P. Couto"

Apresentações semelhantes


Anúncios Google