DESENVOLVIMENTO E TESTE DE UM SIMULADOR PARA O …ee97041/ST1relatorio.pdf · 2001. 10. 26. · Joel Pedro Peixoto de Carvalho Pedro Luís Dias Rodrigues Eng.º Mario Jorge Leitão

Departamento de Engenharia Electrotécnica e de ComputadoresLicenciatura em Engenharia Electrotécnica e de Computadores

4.º ANO – 2.º SEMESTRE

SISTEMAS DE TÉLECOMUNICAÇÕES 1 – 2000/2001

TRABALHO PRÁTICO

DESENVOLVIMENTO E TESTE

DE UM SIMULADOR PARA O

DIMENSIONAMENTO DE UMA

REDE DE ACESSO COM

TRÁFEGO DE VOZ E DADOS

Trabalho elaborado por:

Carla Daniela Gonçalves Neves Joel Pedro Peixoto de Carvalho

Pedro Luís Dias Rodrigues

Eng.º Mario Jorge Leitão Junho 2001

SIMULAÇÃO DE UMA REDE DE ACESSO DE COMUTAÇÃO DE CIRCUITOS

INDICE:

1. Caracterização do trabalho prático..............................................................................2

2. Algumas noções importantes.......................................................................................3

3. Cenário 1......................................................................................................................5

3.1 Enunciado...........................................................................................................5

3.2 Descrição da implementação..............................................................................5

3.3 Resultados...........................................................................................................8

4. Cenário 2......................................................................................................................9

4.1 Enunciados...........................................................................................................9

4.2 Descrição da implementação...............................................................................9

4.3 Resultados..........................................................................................................13

5. Conclusões.................................................................................................................14

5.1 Análise comparativa entre resultados obtidos e esperados................................14

5.2 Algumas notas pertinentes.................................................................................16

6. Anexos.......................................................................................................................17

6.1 O cenário 1.........................................................................................................17

6.1.1 cenario1.cpp.............................................................................................17

6.1.2 cenario1lib.h............................................................................................21

6.2 O cenário 2........................................................................................................23

6.2.1 cenario2.cpp..............................................................................................23

6.2.2 cenario2lib.h.............................................................................................28

SISTEMAS DE TELECOMUNICAÇÕES I 2 / 31


1. CARACTERIZAÇÃO DO TRABALHO PRÁTICO

Basicamente este trabalho visa o desenvolvimento e consequente teste de um simulador para o dimensionamento de uma rede de acesso com dois tipos de tráfego: voz e dados (chamadas de acesso à Internet).

Os objectivos a cumprir são portanto: • A modelização do tráfego oferecido à rede considerando as duas configurações

de acesso referidas acima; • A animação do tráfego sobre a rede recorrendo a técnicas de simulação de

eventos discretos; • A determinação do número de canais que satisfazem as condições impostas pelo

enunciado do trabalho. O ambiente de programação escolhido por nós é o C++. Esta escolha deve-se ao

facto deste ser um ambiente mais versátil e poderoso, uma vez que nos permite de forma relativamente simples lidar com classes e listas ligadas (Cadeias) importantíssimas na elaboração deste trabalho.



2. ALGUMAS NOÇÕES IMPORTANTES 2. ALGUMAS NOÇÕES IMPORTANTES

iceicF ⋅−−= λ1)( iceicF ⋅−−= λ1)( tsetsF ⋅−−= λ1)( tsetsF ⋅−−= λ1)(

)ln(1 uic ⋅−=λ

A simulação por eventos discretos: • É aplicável apenas a sistemas de estados discretos. • As mudanças de estado são determinadas por eventos. • A simulação consiste na animação do sistema analisando o efeito dos sucessivos

eventos no estado do sistema. • Inicializações

- relógio é iniciado a 0. - são determinados os instantes de eventos futuros.

• Fila de eventos - Contém tipo de evento e o instante de ocorrência. - É ordenada por ordem crescente do tempo.

• Avanço do tempo - avança-se o tempo para o próximo evento. - processa-se o evento, actualizando o estado do sistema. - determina-se a ocorrência de futuros eventos. - repete-se o processo.

Simulação do processo de chegada de clientes:

• Tem que respeitar o processo de Poisson: - λ representa a taxa de chegada de clientes - µ representa a taxa de serviço de clientes - eventos ec representam a chegada de um cliente - eventos ep representam a partida de um cliente - processamento de um evento k e consequente determinação de ocorrência de um novo evento k+1 - intervalo entre chegada de clientes (ic) e o tempo de serviço (ts) com distribuição exponencial:

o Funções de distribuição de probabilidade

o Com u gerado aleatóriamente no intervalo [0,1] através da função

random então ic e ts podem ser obtidos da seguinte forma:

Esquematização do modelo funcional a implementar:

)ln(1 uts ⋅−=µ



)ln(1 uic ⋅−=λ

A simulação por eventos discretos: • É aplicável apenas a sistemas de estados discretos. • As mudanças de estado são determinadas por eventos. • A simulação consiste na animação do sistema analisando o efeito dos sucessivos

eventos no estado do sistema. • Inicializações

- relógio é iniciado a 0. - são determinados os instantes de eventos futuros.

• Fila de eventos - Contém tipo de evento e o instante de ocorrência. - É ordenada por ordem crescente do tempo.

• Avanço do tempo - avança-se o tempo para o próximo evento. - processa-se o evento, actualizando o estado do sistema. - determina-se a ocorrência de futuros eventos. - repete-se o processo.

Simulação do processo de chegada de clientes:

• Tem que respeitar o processo de Poisson: - λ representa a taxa de chegada de clientes - µ representa a taxa de serviço de clientes - eventos ec representam a chegada de um cliente - eventos ep representam a partida de um cliente - processamento de um evento k e consequente determinação de ocorrência de um novo evento k+1 - intervalo entre chegada de clientes (ic) e o tempo de serviço (ts) com distribuição exponencial:

o Funções de distribuição de probabilidade

o Com u gerado aleatóriamente no intervalo [0,1] através da função

random então ic e ts podem ser obtidos da seguinte forma:

Esquematização do modelo funcional a implementar:



Algumas equações e cálculos relevantes:

Valor médio................................................

Variância.....................................................

Intervalo de confiança (1-α)%....................



3. CENÁRIO 1

3.1 ENUNCIADO

3.2 DESCRIÇÃO DA IMPLEMENTAÇÃO

Os parâmetros de entrada. O nosso trabalho possuiu como parâmetros de entrada a

percentagem de bloqueio, o número de amostras pretendidas (i.e. o número de vezes que se pretende repetir o processo) e o número de circuitos com os quais pretendemos iniciar a simulação. O número de circuitos com os quais pretendemos iniciar a simulação é um parâmetro de entrada uma vez que nos possibilita não ter de iniciar a simulação com apenas um circuito disponível o que conduziria a uma simulação extremamente morosa. Aquando do teste da probabilidade de bloqueio, se esta não for inferior ao valor estipulado então o número de canais é incrementado até que se satisfaça a condição imposta pela variável de entrada. Associada a esta variável de entrada existe um ‘pequeno’ inconveniente, uma vez que a busca do valor de pretendido de circuitos é obtida por incremento e nunca por decremento, o que significa que quando impomos, através dos parâmetros recursos superiores aos que na verdade seriam necessários a solução será terminantemente errada.

O main(). Sucintamente o nosso programa principal é composto por três ciclos básicos:

• O ciclo for (exterior). Este ciclo impõe que o programa corra o ‘número de amostras vezes’ que foram estipuladas como parâmetros de entrada.

• O ciclo do...while . Este ciclo impõe que se continue nele até que a probabilidade de bloqueio seja inferior ao estipulado nos parâmetros de entrada.

• O ciclo while (mais interior). Este ciclo impõe sejam ‘corridas’ o número total de chamadas na simulação, número este previamente especificado através de um #define.



É notória, pelo enunciado do cenário 1, a inexistência de distinção entre o tráfego de voz e de dados. Mas analisemos a implementação mais de perto:

i. O CICLO WHILE (MAIS INTERIOR).

Aqui é criada uma cadeia (ou lista ligada) na qual serão inseridos eventos constituídos por 3 campos:

- tipo de evento(de chegada ou de partida) - tipo de chamada (de voz ou de dados) - tempo, que servirá para a inserção do evento na lista

A Cadeia está ordenada temporalmente de forma crescente, queremos dizer, o primeiro evento da cadeia é o que tem o menor tempo e consequentemente será o primeiro a sair. Este elemento que sai da cadeia é processado consoante o tipo de evento:

- se é evento de partida: incrementam-se os contadores de chamadas de partida de voz ou de dados (consoante o tipo de chamada) - se é evento de chegada: neste caso, é criado imediatamente um outro evento de chegada com o mesmo tipo de chamada, no entanto, com um tempo diferente que é calculado somando o tempo actual do evento a um outro tempo que é calculado de forma aleatória levando em consideração o número de assinantes livres e a frequência com que é realizada uma chamada. Uma vez atingido este estágio do programa ainda se colocam as seguintes possibilidades:

» caso existam circuitos disponíveis é criado um evento de partida consoante o tipo de chamada. A este novo evento é atribuído um tempo de partida somando o tempo actual a um tempo que é calculado de forma aleatória tendo em conta a duração média da chamada. É então incrementada uma variável que indica que está a ser utilizado mais um circuito. » caso não existam circuitos disponíveis é incrementada a variável que regista as chamadas bloqueadas de voz ou dados.

Uma vez actualizadas as variáveis referidas anteriormente, calcula-se o número total de chamadas que saíram do sistema até ao momento, levando em consideração as variáveis que registam as chamadas de partida de voz e dados mais as chamadas que foram bloqueadas de voz e de dados. Assim que o número de chamadas que saíram do sistema atingir o número pretendido, especificado através do #define n_chamsimul, abandona-se este ciclo.

ii. O CICLO DO...WHILE.

Assim que termina o ciclo anterior calculamos a probabilidade de bloqueio do sistema para um determinado número de circuitos, sendo que essa probabilidade é calculada dividindo a soma das chamadas bloqueadas de voz e de dados pelo número total de chamadas.

- se a probabilidade de bloqueio é menor que a probabilidade de bloqueio especificada nos parâmetros de entrada então saímos do ciclo pois encontramos uma quantidade de circuitos que satisfaz as nossas especificações. - se a probabilidade de bloqueio é maior que a probabilidade de bloqueio especificada nos parâmetros de entrada então ainda não encontramos a quantidade de circuitos que satisfaz as nossas especificações. Desta forma é incrementado o número de circuitos e volta-se a repetir o processo de simulação sucessivamente até que seja dada por verdadeira a condição imposta.



iii. O CICLO FOR (EXTERIOR). Basicamente este ciclo permitirá a manipulação matemática das variáveis criadas e

modificadas durante a simulação. Conforme já referido atrás, o ciclo repetir-se-á consoante o número de amostras que forem especificadas. As operações aqui feitas são:

- acumular a quantidade de circuitos para uma probabilidade de bloqueio menor que a pretendida, numa variável - guardar num vector esse mesmo número de circuitos, para possibilitar o futuro calculo da variância - transferir os valores dos vectores variáveis para outros vectores, responsáveis pelo futuro preenchimento dos histogramas de voz e dados. Quando saímos deste ciclo isto significa que já temos todas as amostras

pretendidas(especificadas previamente). São então imprimidos os resultados obtidos, sendo os histogramas guardados para um ficheiro, ‘histograma.m’, que pode ser aberto em Matlab, sendo apenas necessário escrever o nome histograma para que apareçam os dois histogramas, de voz e dados.

iiii. OS HISTOGRAMAS

O calculo dos Histogramas é feito da seguinte forma: - temos um vector para as chamadas de voz e outro para as chamadas de dados divididos em intervalos de ___segundos e ___ minutos. NOTA: Os valores a colocar em ___seg e ___min devem ser aproximadamente cerca de um quinto da duração média das

respectivas chamadas.

- além disso de cada vez que é criado um evento de partida de voz ou de dados, a duração desse evento é guardada e consoante essa duração um vector vai sendo preenchido - desta forma ao atingirmos o fim do nosso programa temos dois vectores que nos dão a quantidade de chamadas que terminam num determinado intervalo de tempo, isto é, possuímos dois histogramas distintos de durações de chamadas de voz e dados.



3.3 RESULTADOS



4. CENÁRIO 2 4.1 ENUNCIADO

4.2 DESCRIÇÃO DA IMPLEMENTAÇÃO São alistadas abaixo apenas as alterações relevantes em relação ao primeiro cenário.

i. CICLO WHILE (MAIS INTERIOR). Aqui é criada uma cadeia (ou lista ligada) na qual serão inseridos eventos

constituídos por 4 campos: - tipo de evento(de chegada ou de partida) - tipo de chamada (de voz ou de dados) - tempo, que servirá para a inserção do evento na lista - identificador, que servirá para encontrar na lista, cada vez que surja uma partida de dados, o respectivo evento ou ON ou OFF.

A Cadeia está ordenada temporalmente de forma crescente, queremos dizer, o primeiro evento da cadeia é o que tem o menor tempo e consequentemente será o primeiro a sair. Este elemento que sai da cadeia é processado consoante o tipo de evento:

- se é evento de partida: incrementam-se os contadores de chamadas de partida de voz ou de dados (consoante o tipo de chamada) e decrementados os contadores de recursos utilizados de voz ou dados, caso seja um evento de dados faz-se ainda uma pesquisa à lista até se encontrar o respectivo evento de ON ou OFF, essa pesquisa faz-se com base no identificador. Se o evento encontrado na lista estiver ON temos que decrementar as chamadas activas no sistema, caso contrário não se faz nada - se é evento de chegada: neste caso, é criado imediatamente um outro evento de chegada com o mesmo tipo de chamada, no entanto, com um tempo diferente que é calculado somando o tempo actual do evento a um outro tempo que é calculado de forma aleatória levando em consideração o número de assinantes



livres e a frequência com que é realizada uma chamada. Uma vez atingido este estágio do programa ainda se colocam as seguintes possibilidades:

» caso existam circuitos disponíveis é criado um evento de partida consoante o tipo de chamada. A este novo evento é atribuído um tempo de partida somando o tempo actual a um tempo que é calculado de forma aleatória tendo em conta a duração média da chamada. É então incrementada uma variável que indica que está a ser utilizado mais um circuito.

nota: caso seja umachamada de dados nãose coloca a questão deexistirem ou nãocircuitos de dadosdisponiveis, ou seja sãosempre criados eventosde partida.

» caso o evento seja de dados é criado um segundo evento do tipo ON. Este evento terá um identificador igual ao evento de partida criado anteriormente, » caso não existam circuitos disponíveis de voz é incrementada a variável que regista as chamadas bloqueadas de voz.

nota: todas aschamadas de voz etodos os eventos dechegada de dados têmum identificador igual a‘0’, pois não é criadooutro evento paralelo
» caso não existam circuitos disponíveis de dados é incrementada a
variável de circuítos de dados, pois no segundo cenário temos que ter uma quantidade de circuítos que satisfaça o débito de pico.

- se é evento ON: este passará a OFF, sendo decrementada a variável de chamadas de dados activas no sistema. É calculado o histograma e o tempo de duração, tendo em conta a duração média de um evento OFF( 60s para 10% dos casos e 5s nos restantes 90%). - se é evento OFF, este irá passar a ON, sendo calculado o tempo de duração do mesmo com base na duração média de um evento ON( 1s), é também efectuado um incremento da variável de chamadas activas de dados no sistema.

Uma vez actualizadas as variáveis referidas anteriormente, calcula-se o número total

de chamadas que saíram do sistema até ao momento, levando em consideração as variáveis que registam as chamadas de partida de voz e dados mais as chamadas que foram bloqueadas de voz. Assim que o número de chamadas que saíram do sistema atingir o número pretendido, especificado através do #define n_chamsimul, abandona-se este ciclo.

ii. O CICLO FOR (EXTERIOR).

Basicamente este ciclo permitirá a manipulação matemática das variáveis criadas e

modificadas durante a simulação. O ciclo repetir-se-á consoante o número de amostras que forem especificadas. As operações aqui feitas são:

- acumular a quantidade de circuitos para uma probabilidade de bloqueio menor que a pretendida, numa variável - guardar num vector esse mesmo número de circuitos, para possibilitar o futuro calculo da variância - transferir os valores dos vectores variáveis para outros vectores, responsáveis pelo futuro preenchimento dos histogramas de voz e dados. - calcula-se também o débito de médio e o débito de pico. Quando saímos deste ciclo isto significa que já temos todas as amostras

pretendidas(especificadas previamente). É impresso, no ecrã, o número de circuitos de voz e respectivo desvio padrão (necessários para satisfazer uma probabilidade de bloqueio menor que 1%), o número de circuitos de dados necessários para satisfazer o débito de pico, o débito médio e ainda o maior débito de pico obtido de entre as várias amostras. Os histogramas são guardados para um ficheiro, ‘histograma.m’, que pode ser



aberto em Matlab, sendo apenas necessário escrever o nome histograma para que apareçam os dois histogramas pretendidos, o de voz e o de dados.

iii. OS HISTOGRAMAS, O DÉBITO MÉDIO E O DÉBITO DE PICO. »» O histograma de voz é calculado tal como no cenário anterior. »» O histograma de dados é calculado evento a evento (e não segundo a segundo

conforme era especificado no enunciado), sendo o objectivo fornecer-nos a variação do débito médio no tempo. Assim de cada vez que é criado um evento ON, ou cada vez que um evento de ON passe a OFF (e vice versa) é invocada uma função que será a responsável pelo desenho do histograma. Essa função funciona da seguinte maneira:

- existem 2 variáveis que nos indicam o tempo actual da simulação (t_simul), que se altera de evento a evento e o tempo do evento imediatamente anterior(p_t)

- inicialmente t_simul e p_t têm o valor zero - consideremos o diagrama seguinte, considerando que cada salto é de 32

Kbits/s, isto é, a capacidade do canal - Quando chega o primeiro evento as variáveis encontram-se como estão

representadas na figura seguinte

- Quando chega o próximo evento, as variáveis encontrar-se-ão como na figura

abaixo

- É então recorrendo a estas duas variáveis que actualizaremos as outras

variáveis que possibilitarão o desenho do Histograma de dados.

»» O débito médio é calculado da seguinte forma: - cada vez que se cria um evento de ON, a duração do mesmo é acumulada

numa variável



- quando a condição de probabilidade de bloqueio for verdadeira, dividimos a variável anterior pelo tempo que demorou a simulação, que é o tempo do último evento processado, e acumulamos esse valor noutra variável

- por fim quando imprimimos os resultados dividimos a variável anterior pelo número de amostras, para obter uma média e multiplicamos por 32, que é o débito dos canais, obtendo assim o débito médio total (32Kbit/s)

»» O débito de pico é calculado tendo em conta o maior valor do número de

circuitos (recursos) obtidos nas várias simulações, sendo por fim multiplicado por 32 que é o débito de cada canal (32Kbit/s).



4.3 RESULTADOS

0 200 400 600 800 1000 1200 1400 1600 1800 20000

500

1000

1500

2000

2500

3000

Intervalos

Número de Chamadas

Histograma de Voz

-100 0 100 200 300 400 500 600 700 8000

5000

10000

15000

Intervalos

Número de Chamadas

Histograma de Dados



5. CONCLUSÕES

5.1 ANÁLISE COMPARATIVA ENTRE RESULTADOS OBTIDOS E ESPERADOS:

CENÁRIO 1

- Tráfego telefónico máximo Pelos dados fornecidos no guião, determinou-se o valor da intensidade do tráfego:

assm NdA **λ= erlang48480*603*2 ==

Seguidamente , por consulta das Tabelas de Erlang, determinou-se o número que canais para as características da rede a simular:

n=62 canais Uma vez que a probabilidade de bloqueio não é exactamente 1%, nesta situação

particular, determinou-se ainda o seu verdadeiro valor:

[ ]∑

=

==N

k

k

N

kA

NA

NB

0 !

! ⇔ 8,0008,020865,618484,5

!48!62

48

62

0

62

⇒≅==

∑=

EE

k

B

k

k %

- Tráfego Internet máximo

O cálculo dos parâmetros é efectuado da mesma maneira que a situação anterior, no entanto nesta situação o valor dos dados é diferente. O valor da intensidade do tráfego é:

assm NdA **λ= erlang72480*21*3,0 ==

Por consulta das tabelas, determinou-se o número que canais para as características da rede a simular:

n=88 canais Determinou-se o valor da probabilidade de bloqueio:

[ ]∑

=

==N

k

k

N

kA

NA

NB

0 !

! ⇔ 83,00083,020805,118503,1

!72!88

72

88

0

88

⇒≅==

∑=

EE

k

B

k

k %

Isto é, são necessários utilizar 150 circuitos (o valor máximo de circuitos que seriam

utilizados). Calculemos agora o valor mínimo de circuitos que eventualmente seriam utilizados:

- Tráfego telefónico mínimo


Por consulta das tabelas, determinou-se o número que canais para as características da rede a simular:

n=45 canais



[ ]∑

=

==N

k

k

N

kA

NA

NB

0 !

! ⇔ %85,00085.0

!33!45

33

45

0

45

⇒≅=

∑=k

k

k

B

- Tráfego Internet mínimo

assm NdA **λ= erlang5.49330*21*3,0 ==

Determinou-se o número que canais para as características da rede a simular: n=63 canais

[ ]∑

=

==N

k

k

N

kA

NA

NB

0 !

! ⇔ %95,00095.0

!5.49

!635.49

63

0

63

⇒≅=

∑=k

k

k

B

Isto é, nestas condições teríamos um total de 108 circuitos (o valor mínimo de

circuitos que seriam utilizados). Assim sendo, temos um valor máximo e um valor mínimo para o número de

circuitos que pode ser comparado com resultado obtido a partir da simulação, que foi de 112.8 ± 0.492 circuitos. Este valor obtido na simulação é aceitável uma vez que se encontra dentro dos limites impostos teoricamente [ 108 ; 150 ].

De salientar é ainda o facto do tráfego oferecido ao sistema não ser constante, o que nos conduz a uma situação de Distribuição de Engset, no entanto, neste caso não existem tabelas que nos possam auxiliar nos cálculos teóricos.

CENÁRIO 2 Uma vez que agora o tráfego telefónico aparece bem apartado do tráfico de internet,

o calculo teórico, do número de canais necessários é agora bem mais rigoroso:

- Tráfego telefónico máximo


n=62 canais

[ ]∑

=

==N

k

k

N

kA

NA

NB

0 !

! ⇔ 8,0008,020865,618484,5

!48!62

48

62

0

62

⇒≅==

∑=

EE

k

B

k

k %

- Tráfego telefónico mínimo


n=45 canais



[ ]∑

=

==N

k

k

N

kA

NA

NB

0 !

! ⇔ %85,00085.0

!33!45

33

45

0

45

⇒≅=

∑=k

k

k

B

Assim sendo, temos um valor máximo e um valor mínimo para o número de circuitos que pode ser comparado com resultado obtido a partir da simulação, que foi de 49.3 ± 0.352 circuitos. Este valor obtido na simulação é aceitável uma vez que se encontra dentro dos limites impostos teoricamente [ 45 ; 62 ].

Ao observarmos os resultados obtidos nos dois cenários, constatamos que quando fazemos a separação do tráfego de voz e de dados obtemos melhores resultados, pois o número de canais necessários para o Cenário 2 (60) é menor que o número de canais necessário no Cenário 1 (112) o que num cenário real teria vantagens enormes quer em termos económicos, quer em termos de gestão/manutenção de recursos,

5.2 ALGUMAS NOTAS PERTINENTES:

Na elaboração do código do programa/simulador, há que destacar alguns pormenores, principalmente os que permitiram o melhoramento do programa quer em termos de apresentação, quer em termos de execução do segundo cenário:

- Introdução de uma livraria com a Cadeia (Lista ligada) e outras Operações não-principais: foi tomada esta decisão, uma vez que, os conteúdos desta(s) livraria(s)( cenario1lib.h; cenario2lib.h) não são de tão elevada importância para o funcionamento do simulador, quando comparados com a função main() e as quatro funções principais que constam dos dois programas (chegadaCliente, Especificacoes, InicializaCadeiaEventos, Calculos), no entanto, estes mesmos são necessários e fundamentais para a compreensão/funcionamento do simulador.

- Introdução de uma função que Limpa Vectores (limpavectores): esta função, faz com que os vectores sejam inicializados a zero. Assim, em cada amostra, os mesmos estarão limpos, de modo a evitar uma eventual adulteração de resultados;

- Introdução de uma função que Preenche Vectores (preenchevectores): nesta de função, como o próprio nome indica, faz-se o preenchimento dos vectores, de modo a que posteriormente se possa efectuar o tratamento do seu conteúdo para a elaboração dos histogramas;

- Introdução de uma estrutura que contem as Variáveis Globais (globalvars): o recurso a este tipo de variáveis é explicado pela fácil implementação código final. Assim, não será necessário transportar os valores das respectivas variáveis pelas diversas funções do programa, tornando assim a leitura do programa mais legível e o seu manuseamento mais simples;

- Introdução de Nova Operação de Pesquisa na Cadeia de Eventos (newSearch): Esta operação, no caso de um evento de partida de dados, tem como objectivo encontrar, com base no identificador (id), o respectivo evento ou ON ou OFF da mesma chamada;

- O vector do histograma de dados tem 25 posições, devido ao facto do débito de pico esperado ser de cerca de 700 Kbit/s. Logo, uma vez que 25 × 32 = 800, temos posições suficientes para desenhar o histograma.



6. ANEXOS 6.1 O CENÁRIO 1

6.1.1 cenario1.cpp

#include<iostream.h>#include<math.h>#include<stdlib.h>#include<time.h>#include<fstream.h> //histograma#include"cenario1lib.h"

#define n_chamsimul 100000//número de chamadas na simulação#define lambdavoz 2.00/3600 //Tráfego *#define umvoz 1.00/(3*60) //telefónico (/Especificações do enunciado docenário 1)#define lambdadados 0.30/3600//Tráfego *#define umdados 1.00/(30*60)//internet *

void InicializaCadeiaEventos(chamada& w,class Chain& Cadeia);void Especificacoes(float& p_bloq,int& d_intervvoz,int& d_intervdados,int&dur_histvoz,int& dur_histdados,int& n_circ,int& n_amostras);void chegadaCliente(float t_simul,int n_circuitos,int& c_bloqvoz,int&c_bloqdados,chamada& w,class Chain& Cadeia,int *histvozvar,int *histdadosvar,intn_intervvoz,int n_intervdados,int d_intervvoz,int d_intervdados);void Histogramas(float tu,int *histog,int n_interv,int d_interv);void Calculos(int n_circuitos,int n_intervvoz,int n_intervdados,int *histvoz,int*histdados,int n_amostras,int *var,int d_intervvoz, int d_intervdados,int c_bloqvoz,intc_bloqdados,int c_voz,int c_dados);

float ts(float u); //tempo de serviço(indeterminado)float ic(float l); //intervalo de chegade de clientes(longo)

int media=0;

int main(){int

n_circuitos,d_intervvoz,d_intervdados,dur_histvoz,dur_histdados,n_intervvoz,n_intervdados,t_intervdados,t_intervvoz,c_bloqvoz,c_bloqdados,c_voz,c_dados,n_amostras,n_circ;

int n_totcham,j,k;float t_simul,p_bloq;chamada w;srand(time(NULL));//sementeEspecificacoes(p_bloq,d_intervvoz,d_intervdados,dur_histvoz,dur_histdados,n_circ,

n_amostras);n_intervvoz=dur_histvoz*3600/d_intervvoz;n_intervdados=dur_histdados*3600/d_intervdados;int

histvoz[n_intervvoz+1],histdados[n_intervdados+1],histvozvar[n_intervvoz+1],histdadosvar[n_intervdados+1],var[n_amostras];

n_circuitos=n_circ;for(int h=0;h<=n_intervvoz;h++)

histvoz[h]=0;for(int m=0;m<=n_intervdados;m++)

histdados[m]=0;for(int g=0;g<n_amostras;g++){do{

t_simul=c_bloqvoz=c_bloqdados=c_voz=n_totcham=c_dados=0;Chain Cadeia;InicializaCadeiaEventos(w,Cadeia); //lança dois eventos de chegada: voz e

dadosfor(int i=0;i<=n_intervvoz;i++)

histvozvar[i]=0;t_intervvoz=d_intervvoz;for(int n=0;n<=n_intervdados;n++)

histdadosvar[n]=0;t_intervdados=d_intervdados;n_circuitos++;while(n_totcham<n_chamsimul){

n_totcham=c_bloqvoz+c_bloqdados+c_voz+c_dados;Cadeia.Delete(w);



t_simul=w.t;switch(w.te){

case ep:if(w.tc==voz)

c_voz++;else

c_dados++;break;case ec:

chegadaCliente(t_simul,n_circuitos,c_bloqvoz,c_bloqdados,w,Cadeia,histvozvar,histdadosvar,n_intervvoz,n_intervdados,d_intervvoz,d_intervdados);

break;}

}Cadeia.~Chain();

}while(p_bloq<(float) (c_bloqvoz+c_bloqdados)/n_totcham*100); //testa prob.bloq. depois dela realmente existir

media=media+n_circuitos;var[g]=n_circuitos;for(int l=0;l<=n_intervvoz;l++)

histvoz[l]=histvoz[l]+histvozvar[l];for(int s=0;s<=n_intervdados;s++)

histdados[s]=histdados[s]+histdadosvar[s];n_circuitos--;}Calculos(n_circuitos,n_intervvoz,n_intervdados,histvoz,histdados,n_amostras,var,d

_intervvoz,d_intervdados,c_bloqvoz,c_bloqdados,c_voz,c_dados);return 0;

}

void InicializaCadeiaEventos(chamada& w,class Chain& Cadeia){ //Qd arranca a Listaestá vazia

int k;float v,d;v=480*lambdavoz; //obrigo 2 primeirosd=480*lambdadados; //eventos de chegadaw.t=ic(v);w.te=ec;w.tc=voz;k=Cadeia.Search(w.t);Cadeia.Insert(k,w);w.t=ic(d);w.te=ec;w.tc=dados;k=Cadeia.Search(w.t);Cadeia.Insert(k,w);return;

}

void Especificacoes(float& p_bloq,int& d_intervvoz,int& d_intervdados,int&dur_histvoz,int& dur_histdados,int& n_circ,int& n_amostras){

cout<<"**********************************************************************\n";cout<<"************ ESPECIFICACOES ***********************\n";cout<<"**********************************************************************\n";cout<<"Especifique a percentagem maxima de bloqueio pretendida:";cin>>p_bloq;cout<<"Indique o número de amostras pretendidas:";cin>>n_amostras;cout<<"Refira o número de circuitos com que pretende iniciar:";cin>>n_circ;cout<<"Refira a duracao(em segundos) pretendida dos intervalos do histograma de

voz:";cin>>d_intervvoz;cout<<"Refira a duracao(em segundos) pretendida dos intervalos do histograma de

dados:";cin>>d_intervdados;cout<<"Refira a precisao(em horas) do histograma de voz:";cin>>dur_histvoz;cout<<"Refira a precisao(em horas) do histograma de dados:";cin>>dur_histdados;cout<<"***********************************************************************\n"

;return;



}

void chegadaCliente(float t_simul,int n_circuitos,int& c_bloqvoz,int&c_bloqdados,chamada& w,class Chain& Cadeia,int *histvozvar,int *histdadosvar,intn_intervvoz,int n_intervdados,int d_intervvoz,int d_intervdados){

int k1;float t_umvoz,t_umdados;float v,d;v=(482-Cadeia.Length())*lambdavoz; // (480+2 gerados acima)d=(482-Cadeia.Length())*lambdadados; // (480+2 gerados acima)switch(w.tc){ //gera evento de chegada

case voz:w.t=t_simul+ic(v); //tempo de chegada do proximo cliente vozk1=Cadeia.Search(w.t);Cadeia.Insert(k1,w); //insere novo evento de chegada na Lista

Ligadabreak;

case dados:w.t=t_simul+ic(d); //tempo de chegada do proximo cliente

dadosk1=Cadeia.Search(w.t);Cadeia.Insert(k1,w); //insere novo evento de chegada na Lista

Ligadabreak;

}if(Cadeia.Length()>=n_circuitos+2){

if(w.tc==voz)c_bloqvoz++;

elsec_bloqdados++;

return;}switch(w.tc){ //caso a cadeia nao esteja completa -> gera partida

case voz:t_umvoz=ts(umvoz);//w.t=t_simul+t_umvoz;w.te=ep;k1=Cadeia.Search(w.t);Cadeia.Insert(k1,w);Histogramas(t_umvoz,histvozvar,n_intervvoz,d_intervvoz);break;

case dados:t_umdados=ts(umdados);w.t=t_simul+t_umdados;w.te=ep;k1=Cadeia.Search(w.t);Cadeia.Insert(k1,w);Histogramas(t_umdados,histdadosvar,n_intervdados,d_intervdados);break;

}return;

}

void Calculos(int n_circuitos,int n_intervvoz,int n_intervdados,int *histvoz,int*histdados,int n_amostras,int *var,int d_intervvoz,int d_intervdados,int c_bloqvoz,intc_bloqdados,int c_voz,int c_dados){

float mediatotal,s=0,s2;

ofstream histg("histograma.m");//Ficheiro que imprime os histogramas no matlabhistg<<"hist_v = [\n";

//Histograma de vozfor(int i=1;i<=n_intervvoz+1;i++)

//histg<<i*d_intervvoz<<" "<<histvoz[i-1]/n_amostras<<";\n";

//histg<<"]\nfigure(1);\n";

//histg<<"bar(hist_v(:,1),hist_v(:,2)),\n xlabel('Intervalos Tempo'),\n

ylabel('Número de chamadas'),\n title('Histograma de Voz')\n";////

histg<<"hist_d = [\n";// Histograma de dados//

for(int j=1;j<=n_intervdados+1;j++)//



histg<<j*d_intervdados<<" "<<histdados[j-1]/n_amostras<<";\n";//

histg<<"]\nfigure(2);\n";//

histg<<"bar(hist_d(:,1),hist_d(:,2)),\n xlabel('Intervalos Tempo'),\nylabel('Número de chamadas'),\n title('Histograma de Dados')\n";//

histg.close();//

mediatotal=media/n_amostras; //Estima o valor mediofor(int g=0;g<n_amostras;g++) //Calculo

s=s+((var[g]-mediatotal)*(var[g]-mediatotal)); //das2=s/(n_amostras-1); //variancia

cout<<"///////////////////////////////////////////////////////////////////\n";cout<<"///////// RESULTADOS DA SIMULACAO ////////////\n";cout<<"///////////////////////////////////////////////////////////////////\n";cout<<"Intervalo de Confiança: "<<(float)media/n_amostras<<" +/-

"<<(double)1.65*sqrt(s2/n_amostras)<<"\n"; //calcula e imprimecout<<"Número Total de chamadas BLOQUEADAS: "<<c_bloqvoz+c_bloqdados<<"\n";

// *cout<<" bloqueadas de voz: "<<c_bloqvoz<<"\n";

// *cout<<" bloqueadas de dados: "<<c_bloqdados<<"\n";

// *cout<<"Número Total de chamadas EFECTUADAS: "<<c_voz+c_dados<<"\n";

// *cout<<" chamadas de voz : "<<c_voz<<"\n";

// *cout<<" chamadas de dados: "<<c_dados<<"\n";

// *cout<<"///////////////////////////////////////////////////////////////////\n";return;

}



6.1.2 cenario1lib.h float ts(float u){return (-1/u*log((float) (rand()/(RAND_MAX+1.0)))); //If you want to generate a randominteger between 0 and 1}

float ic(float l){return (-1/l*log((float) (rand()/(RAND_MAX+1.0)))); //If you want to generate a randominteger between 0 and 1}

typedef enum{dados,voz}tipochamada; //tipo da chamada de dados ou voztypedef enum{ec,ep}tipoevento; //tipo do evento de chegada ou partida

void Histogramas(float tu,int *histog,int n_interv,int d_interv){ //diz respeito aohistograma

int i,j;for(i=1;i<=n_interv;i++){

if(tu<=i*d_interv){histog[i-1]++;return;

}}histog[i-1]++;

}

struct chamada{tipochamada tc;tipoevento te;float t;

};

//***Lista Ligada(Cadeia)****************************************class ChainNode{

friend class Chain; //classe com dois campos: data e chainNodeprivate:

chamada data;ChainNode *link;

};

class Chain{public:

Chain() {first=0;}~Chain();int Length() const;int Search(const float& x) const;Chain& Delete(chamada& w);Chain& Insert(int k,const chamada& w);

private://pointer to first nodeChainNode *first;

};

//destutor da cadeiaChain::~Chain(){//chain destructor//delete all nodes in chain

ChainNode *next; //next nodewhile(first){next=first->link;delete first;first=next;}

}

//tamanho da cadeiaint Chain::Length() const{//return number of elements in the chain



ChainNode *current=first;int len=0;while(current){len++;current=current->link;}return len;

}

//operação de procura na cadeiaint Chain::Search(const float& x) const{//locate x, return position of x if found//return 0 if x not in the chain

ChainNode *current=first;int index=0; //index of currentwhile(current && current->data.t<x){

current=current->link;index++;}return index;

}//Apagar da cadeiaChain& Chain::Delete(chamada& w){

ChainNode *p=first;first=first->link;//save k'th element and free node p

w.t=p->data.t;w.tc=p->data.tc;w.te=p->data.te;

delete p;return *this;

}//Inserir na cadeiaChain& Chain::Insert(int k, const chamada& w){//insert x after the k'th element

//p wil eventually point to the k'th nodeChainNode *p=first;for(int index=1;index<k && p;index++)p=p->link;//move p to k'th//insertChainNode *y=new ChainNode ;

y->data.t=w.t;y->data.tc=w.tc;y->data.te=w.te;

if(k){//insert after py->link=p->link;p->link=y;

}else{//insert as first element

y->link=first;first=y;

}return *this;

}



6.2 O CENÁRIO 2 6.2.1 cenario2.cpp

#include <iostream.h>#include <math.h>#include <stdlib.h>#include <time.h>#include <fstream.h>#include "cenario2lib.h"

#define n_chamsimul 20000 //número total de chamadas utilizadas na simulação#define lambdavoz 2.00/3600 //lambda de voz#define miuvoz 1.00/(3*60) //miu de voz#define lambdadados 0.30/3600 //lambda de dados#define miudados 1.00/(30*60) //miu de dados#define miuON 1 //miu ON#define miuOFF60 1.00/60 //miu OFF 60s#define miuOFF5 1.00/5 //miu OFF 5s

struct globalvars{int n_circvoz,n_circdados; //canais voz para prob bloq inferior ao

pretendido,canais dados pra transportar o debito de picoint d_intvoz,d_histvoz,n_intervvoz; // dur interv Histog voz, duração Hist Voz,

Quantidade intervalos Hitog Vozint c_bloqvoz; //chamadas bloqueadas de vozint c_partvoz,c_partdados; //chamadas de voz que deixam o sistema

normalmente,ide para dadosint c_voz,c_dados; //chamadas de voz e de dados actualmente no sistemaint c_dados_on; //chamadas de dados activasint n_c_dados,n_c_voz; //acumula número de canais de voz por amostra, idem para

dadosint n_amostras; // número de vezes que se pretende correr o programafloat t_simul; // tempo de simulação actualfloat p_bloq; // Prob Bloqueioint id_aux; // identificador de chamadas de dadosint debpico; // debito de picofloat debmedio; // debito mediofloat debmediotot; // debito medio totalfloat p_t; // previous time

};

void Especificacoes(globalvars& glb);void InicializaCadeiaEventos(chamada& w,class Chain& Cadeia); //lança dois eventos dechegada, um de voz e um de dadosvoid chegadaCliente(globalvars& glb,chamada& w,class Chain& Cadeia,float*histvozvar,float *histdadosvar);//void histogramavoz(float tu,float *histg,int n_int,int d_int); //constroi o histogramade Vozvoid histogramadados(globalvars& glb,float *histdv); // constroi o histograma de Dadosvoid LimpaVectores(int n_int,float *hist); //inicializa os arrays a zerovoid PreencheVectores(int n_int,float *hist,float *histg); //carraga os arrays fixos comos globalvarsvoid Calculos(globalvars& glb,float *histvoz,float *histdados,int *variancia,int*v_dados);float ts(float u); //calcula o tempo de serviçofloat ic(float l); //calcula o tempo da proxima chagada

int main(){chamada w;globalvars glb;int n_totcham,k; //número total de chamadasfloat tmiudados;glb.n_c_voz=glb.n_c_dados=glb.debpico=0;glb.debmediotot=0;srand(time(NULL)); //semente da função rand(), inicializa da maneira mais

aleatória possivelEspecificacoes(glb);int variancia[glb.n_amostras],v_dados[glb.n_amostras];glb.n_intervvoz=glb.d_histvoz*60/glb.d_intvoz;float histvoz[glb.n_intervvoz+1],histdados[25];float histvozvar[glb.n_intervvoz+1],histdadosvar[25];//histogramasLimpaVectores(glb.n_intervvoz,histvoz);



LimpaVectores(24,histdados);for(int g=0;g<glb.n_amostras;g++){glb.n_circvoz=glb.n_circvoz-2;

do{

glb.n_circdados=glb.c_dados=glb.id_aux=glb.c_bloqvoz=glb.c_partvoz=glb.c_partdados=n_totcham=glb.c_voz=glb.c_dados_on=0; //inicializa as variáveis, pois no fim de cadaciclo devem voltar a '0'

glb.debmedio=glb.p_t=0;Chain Cadeia; //cria a CadeiaInicializaCadeiaEventos(w,Cadeia);LimpaVectores(glb.n_intervvoz,histvozvar);LimpaVectores(24,histdadosvar);glb.n_circvoz++;

while(n_totcham<n_chamsimul){ //testa com 100000 chamadasn_totcham=glb.c_bloqvoz+glb.c_partvoz+glb.c_partdados;Cadeia.Delete(1,w); //apaga a primeira posição da Cadeiaglb.t_simul=w.t; //actualiza o tempo de simulaçãoswitch(w.te){ //alterna conforme o parametro w.te da

chamada que foi apagadacase ep:

if(w.tc==voz){glb.c_partvoz++;glb.c_voz--;

}else{glb.c_partdados++;glb.c_dados--;k=Cadeia.newSearch(w.id);Cadeia.Delete(k,w);if(w.te==ON) //se o evento

correspondente indicado pelo idificador estiver OFF então já não está contabilizado emc_dados_on

histogramadados(glb,histdadosvar);glb.c_dados_on--;

}break;case ec:

chegadaCliente(glb,w,Cadeia,histvozvar,histdadosvar);break;

case ON: //se estiver ON passa a OFF e calcula-se otempo de duração deste

w.te=OFF;if((float)

(rand()/(RAND_MAX+1.0))<=0.9)w.t=glb.t_simul+ts(miuOFF5);else w.t=glb.t_simul+ts(miuOFF60);

histogramadados(glb,histdadosvar);k=Cadeia.Search(w.t);

Cadeia.Insert(k,w);glb.c_dados_on--;

break;case OFF: //se estiver OFF passa a ON e calcula-se

o tempo de duração destew.te=ON;

histogramadados(glb,histdadosvar);glb.c_dados_on++;

if(glb.c_dados_on>glb.n_circdados)//caso necessário aumenta-se o número de canais de dados

glb.n_circdados++;tmiudados=ts(miuON);

glb.debmedio=glb.debmedio+tmiudados;w.t=glb.t_simul+tmiudados;k=Cadeia.Search(w.t);Cadeia.Insert(k,w);

break;}

}Cadeia.~Chain(); //apaga a Cadeia

}while(glb.p_bloq<(float)

glb.c_bloqvoz/(glb.c_bloqvoz+glb.c_partvoz)*100);glb.n_c_voz=glb.n_c_voz+glb.n_circvoz; //assim uma média da prob. de

bloqueio e



variancia[g]=glb.n_circvoz; //a respectiva variância, com um intervalo deconfiança de 90%

glb.n_c_dados=glb.n_c_dados+glb.n_circdados;v_dados[g]=glb.n_circdados;if(glb.debpico<glb.n_circdados) //guarda de entre as várias amostras a

que necessitou de um maior número de canais de dadosglb.debpico=glb.n_circdados;

PreencheVectores(glb.n_intervvoz,histvoz,histvozvar);PreencheVectores(24,histdados,histdadosvar);glb.debmediotot=glb.debmediotot+glb.debmedio/glb.t_simul;

}glb.debmedio=glb.debmedio/glb.t_simul;Calculos(glb,histvoz,histdados,variancia,v_dados);return 0;

}

void InicializaCadeiaEventos(chamada& w,class Chain& Cadeia){int k;float v,d;v=480*lambdavoz;d=480*lambdadados;w.t=ic(v);w.te=ec;w.tc=voz;w.id=0;k=Cadeia.Search(w.t);Cadeia.Insert(k,w);w.t=ic(d);w.te=ec;w.tc=dados;w.id=0;k=Cadeia.Search(w.t);Cadeia.Insert(k,w);return;

}

void Especificacoes(globalvars& glb){cout<<"\n";cout<<"******************************************************************\n";cout<<"********************* ESPECIFICACOES **********\n";cout<<"******************************************************************\n";cout<<"Especifique a percentagem maxima de bloqueio pretendida:";cin>>glb.p_bloq;cout<<"Indique o número de amostras pretendidas:";cin>>glb.n_amostras;cout<<"Refira o número de circuitos com que pretende iniciar:";cin>>glb.n_circvoz;cout<<"Refira a duracao(em segundos) pretendida dos intervalos do histograma de

voz:";cin>>glb.d_intvoz;cout<<"Refira a duracao(em minutos) do histograma de voz:";cin>>glb.d_histvoz;cout<<"********************************************************************\n";return;

}

void chegadaCliente(globalvars& glb,chamada& w,class Chain& Cadeia,float*histvozvar,float *histdadosvar){

int k1;float v,d,tmiuvoz,tmiudados;switch(w.tc){ //cria eventos de chegada consoante o parametro z.tc da chamada que

foi apagada da Cadeiacase voz:

v=(480-(glb.c_voz+glb.c_dados))*lambdavoz; //calcula o lambda devoz consoante o número de assinantes que se encontram no sistema

w.t=glb.t_simul+ic(v);k1=Cadeia.Search(w.t);Cadeia.Insert(k1,w);

break;case dados:

d=(480-(glb.c_voz+glb.c_dados))*lambdadados; //calcula o lambda dedados consoante o número de assinantes que se encontram no sistema

w.t=glb.t_simul+ic(d);k1=Cadeia.Search(w.t);



Cadeia.Insert(k1,w);break;

}if(w.tc==voz && glb.c_voz>glb.n_circvoz){

glb.c_bloqvoz++; //a chamada é bloqueadareturn;

}if(w.tc==dados && glb.c_dados_on>glb.n_circdados)

glb.n_circdados++;switch(w.tc){ //se não foi bloqueada então existem recursos e gera-se um novo

evento de partida, segundo w.tccase voz:

tmiuvoz=ts(miuvoz);w.t=glb.t_simul+tmiuvoz;w.te=ep;

w.id=0;k1=Cadeia.Search(w.t);Cadeia.Insert(k1,w);histogramavoz(tmiuvoz,histvozvar,glb.n_intervvoz,glb.d_intvoz);

//preenche um histograma variável de vozglb.c_voz++;

break;case dados:

histogramadados(glb,histdadosvar);glb.id_aux++;w.t=glb.t_simul+ts(miudados);

w.te=ep;w.id=glb.id_aux;k1=Cadeia.Search(w.t);Cadeia.Insert(k1,w);glb.c_dados_on++;glb.c_dados++;w.te=ON;tmiudados=ts(miuON);

glb.debmedio=glb.debmedio+tmiudados;w.t=glb.t_simul+tmiudados;k1=Cadeia.Search(w.t);Cadeia.Insert(k1,w);

break;}return;

}

void Calculos(globalvars& glb,float *histvoz,float *histdados,int *variancia,int*v_dados){

float ntc_voz;float medtotvoz,medtotdados;float svoz=0,sdados=0;float stotaldados=0,stotalvoz=0;

ofstream histograma("histograma.m");histograma<<"hist_voz=[\n";for(int i=1;i<=glb.n_intervvoz+1;i++)

histograma<<i*glb.d_intvoz<<" "<<histvoz[i-1]/glb.n_amostras<<"\n";histograma<<"];\n figure(1)\n";histograma<<"bar(hist_voz(:,1),hist_voz(:,2)),\n xlabel('Intervalos'),\n

ylabel('Número de Chamadas'),\n title('Histograma de Voz')\n";histograma<<"hist_dados=[\n";for(int i=0;i<=24;i++)

histograma<<i*32<<" "<<histdados[i]/glb.n_amostras<<"\n";histograma<<"];\n figure(2)\n";histograma<<"bar(hist_dados(:,1),hist_dados(:,2)),\n xlabel('Intervalos'),\n

ylabel('Número de Chamadas'),\n title('Histograma de Dados')";histograma.close();

ntc_voz=(float)glb.n_c_voz/glb.n_amostras;medtotvoz=(float) glb.n_c_voz/glb.n_amostras;medtotdados=(float)glb.n_c_dados/glb.n_amostras;

for(int g=0;g<glb.n_amostras;g++){svoz=svoz+((variancia[g]-medtotvoz)*(variancia[g]-medtotvoz));sdados=sdados+((v_dados[g]-medtotdados)*(v_dados[g]-medtotdados));

}

stotalvoz=svoz/(glb.n_amostras-1);stotaldados=sdados/(glb.n_amostras-1);



cout<<"\n";cout<<"///////////////////////////////////////////////////////////////////\n";cout<<"///////// RESULTADOS DA SIMULACAO ////////////\n";cout<<"///////////////////////////////////////////////////////////////////\n";cout<<"VOZ -->> intervalo de confiança "<<medtotvoz<<" +/-

"<<(double)1.65*sqrt(stotalvoz/glb.n_amostras)<<" circuitos de Voz\n\n";cout<<"DADOS -->> intervalo de confianca "<<medtotdados/2<<" +/-

"<<((double)1.65*sqrt(stotaldados/glb.n_amostras))/2<<" circuitos de Dados "<<"\n\n";cout<<"Debito medio: "<<glb.debmediotot/glb.n_amostras<<" x 32 Kbits =

"<<glb.debmediotot/glb.n_amostras*32<<" Kbits\n\n";cout<<"Debito de pico: "<<(float)glb.debpico/2<<" x 64 Kbits =

"<<(float)glb.debpico/2*64<<" Kbits \n\n";cout<<"///////////////////////////////////////////////////////////////////\n";return;

}



6.2.2 cenario2lib.h

float ts(float u){float f;do{f=(float) (rand()/(RAND_MAX+1.0));}while(f==0);

return (-1/u*log(f));}

float ic(float l){float f;do{

f=(float) (rand()/(RAND_MAX+1.0));}while(f==0);return (-1/l*log(f));

}

void LimpaVectores(int n_int,float *hist){ //inicializa os arrays (histogramas)for(int i=0;i<=n_int;i++)

hist[i]=0;}

void PreencheVectores(int n_int,float *hist,float *histg){ //carrega os histogramasfinais com os variáveis

for(int l=0;l<=n_int;l++)hist[l]=hist[l]+histg[l];

}

void histogramavoz(float tu,float *histg,int n_int,int d_int){ //preenche os histogramasvariáveis

int i;for(i=1;i<=n_int;i++){

if(tu<=i*d_int){histg[i-1]++;return;

}}histg[i-1]++;return;

}

void histogramadados(globalvars& glb,float *histdv){histdv[glb.c_dados_on]=histdv[glb.c_dados_on]+glb.t_simul-glb.p_t;glb.p_t=glb.t_simul;

}

typedef enum{dados,voz}tipochamada; //tipo da chamada de dados ou voztypedef enum{ec,ep,ON,OFF}tipoevento; //tipo do evento de chegada ou partida

struct chamada{tipochamada tc;tipoevento te;int id;float t;

};

//***Lista Ligada(Cadeia)****************************************class ChainNode{

friend class Chain; //classe com dois campos: data e chainNodeprivate:

chamada data;ChainNode *link;

};

class Chain{public:



Chain() {first=0;}~Chain();int Search(const float& x) const;int NewSearch(const int& x) const;Chain& Delete(int k,chamada& w);Chain& Insert(int k,const chamada& w);

private://pointer to first nodeChainNode *first;

};

//destutor da cadeiaChain::~Chain(){//chain destructor//delete all nodes in chain

ChainNode *next; //next nodewhile(first){

next=first->link;delete first;first=next;

}}

//operação de procura na cadeiaint Chain::Search(const float& x) const{ //locate x, return position of x if found//return 0 if x not in the chain

ChainNode *current=first;int index=0; //index of currentwhile(current && current->data.t<x){

current=current->link;index++;

}return index;

}

//outra operação de procura na cadeia que permite a busca da variável de identificaçãoint Chain::newSearch(const int& x) const{//locate x, return position of x if found//return 0 if x not in the chain

ChainNode *current=first;int index=0; //index of currentwhile(current && current->data.id!=x){

current=current->link;index++;

}return index+1;

}

//Apagar da cadeiaChain& Chain::Delete(int k,chamada& w){

ChainNode *p=first;if(k==1)

first=first->link;else{

ChainNode *q=first;for(int index=1;index<k-1 && q;index++)

q=q->link;p=q->link;q->link=p->link;

}//save k'th element and free node pw.t=p->data.t;w.tc=p->data.tc;w.te=p->data.te;w.id=p->data.id;delete p;return *this;

}

//Inserir na cadeiaChain& Chain::Insert(int k, const chamada& w){//insert x after the k'th element

//p wil eventually point to the k'th nodeChainNode *p=first;for(int index=1;index<k && p;index++)

p=p->link;//move p to k'th//insertChainNode *y=new ChainNode ;y->data.t=w.t;y->data.tc=w.tc;



y->data.te=w.te;y->data.id=w.id;if(k){//insert after p

y->link=p->link;p->link=y;

}else{//insert as first element

y->link=first;first=y;

}return *this;

}


Documents

DESENVOLVIMENTO E TESTE DE UM SIMULADOR PARA O …ee97041/ST1relatorio.pdf · 2001. 10. 26. · Joel Pedro Peixoto de Carvalho Pedro Luís Dias Rodrigues Eng.º Mario Jorge Leitão