Modelagem e Simulação Discreta: Brauliro G Leal

Versão 10/03/2022
Brauliro G Leal
Modelagem e Simulação Discreta
Quarta Edição
Juazeiro – BA
2021
Modelagem e Simulação Discreta 2
Copyright© 2016, 2017, 2018, 2019, 2020, 2021 by Brauliro Gonçalves Leal
O conteúdo deste livro eletrônico é livre para uso de qualquer natureza desde que citado a
fonte. Toda e qualquer parte desta publicação pode ser reproduzida, distribuída ou
transmitida de qualquer forma ou por qualquer meio, ou armazenada de qualquer forma ou
em qualquer sistema desde que reconhecida a autoria.
Atribuição-CompartilhaIgual – esta licença permite que outros remixem, adaptem e

criem a partir deste trabalho, mesmo para fins comerciais, desde que lhe atribuam o
devido crédito e que licenciem as novas criações sob termos idênticos
(creativecommons.org/licenses).
e-mail: ccmp0057@gmail.com
Quarta Edição Eletrônica: dezembro de 2021
ISBN: a ser feito#
O autor
Brauliro Gonçalves Leal
Professor do Colegiado de Engenharia da Computação

Universidade Federal do Vale do São Francisco
Avenida Antônio Carlos Magalhães, 510 Santo Antônio
Juazeiro/BA – Brasil 48.902-300
e-mail: brauliro.leal@univasf.edu.br
site: www.univasf.edu.br/~brauliro.leal
Sobre este documento
Este documento foi escrito em LibreOffice (www.libreoffice.org), suas imagens foram

produzidas pelo Kolourpaint (www.kolourpaint.org), seus programas foram editados na IDE
Code::Blocks (www.codeblocks.org) e compilados com o GNU GCC (gcc.gnu.org). O Sistema
Operacional utilizado foi o GNU/Linux Mint Cinnamon.
Software livre é a melhor ideia!

Pois o conforto intelectual e o hábito têm horror das mensagens que

os incomodam.
Edgar Morin (Le Monde: 20 de abril de 2020)

Modelagem e Simulação Discreta
Prefácio
O objetivo principal deste livro é servir de texto para a disciplina Modelagem e Simulação do
curso de Engenharia da Computação do Colegiado de Engenharia da Computação da
Universidade Federal do Vale do São Francisco.
Os grandes temas deste livro são: Sistemas de Fila, Simulação de Sistemas de Fila, Análise de
Resultados Simulados, Verificação e Validação de Modelos, Geração de Números Aleatórios e
Geração de Variáveis Aleatórias.
Neste texto foram construídos os Modelos Analítico, Conceitual e Computacional de Sistemas

de Fila a partir da Teoria de Filas e dos Modelos de Sistemas de Filas. Estes modelos permitem
tratar os temas deste livro e são os eixos que dão suporte à teoria e às aplicações da
Modelagem e Simulação Discreta.
O Modelo Conceitual de Sistemas de Fila e seu respectivo Modelo Computacional, aqui

apresentados, foram feitos em duas partes. Na primeira parte foi tratado o processo de
simulação discreta e na segunda a análise estatística dos resultados. Desta forma, são
enfatizadas as variáveis de real interesse para a simulação, tornando o modelo mais simples
de ser compreendido. Esta abordagem revelou-se assaz didática.
O uso de modelos é amplamente aceito pois permite estudar problemas aos poucos –
ampliando o escopo quando necessário, maior facilidade para testar um sistema antes de lhe
dar forma final – reduz custos, melhora a comunicação entre os membros de uma equipe –
aumento da eficiência das equipes, e contribui com a publicidade dos seus resultados –
favorece o entendimento do público de interesse.
Os modelos computacionais foram implementados em C++, pelo rigor da linguagem, e em

Javascript com HTML5, para permitir a visualização gráfica e a dinâmica da simulação
discreta, viabilizando seu uso em navegadores web. Esta implementação permite a avaliação
gráfica do comportamento dos sistemas simulados, dando grande estímulo à aprendizagem,
com resultados inspiradores.
Os algoritmos para a Geração de Variáveis Aleatórias também são contribuições relevantes,

permitem gerar várias funções de distribuição acumuladas, discretas e contínuas, a partir de
números aleatórios, dando suporte à simulação computacional.
Outros algoritmos foram desenvolvidos, destinados aos tópicos relevantes da Simulação de

Sistemas Simples de Fila, para Verificação e Validação de Modelos e também para a Análise
de Resultados Simulados, com destaque para os métodos de Replicação Independente e
Média de Lotes.
O autor espera que tenha contribuído com o ensino destes conteúdos de modo a torná-los
mais atraentes, visuais, dinâmicos e aplicados nas diversas áreas de conhecimento, quando
cabível. Na esperança de que os estudantes descubram a expressão racional que se
descobriu no mundo e que os ajude a reinventá-la.
Os softwares e material didáticos auxiliares foram incluídos no texto e tem como finalidade
pedagógica, destinam-se a ilustrar os conceitos da disciplina, estão sendo melhorados e
otimizados e são de uso livre. O autor não assume quaisquer responsabilidades pelo seu uso
e/ou pelas consequências de seu uso.
Construindo a Modelagem e Simulação de Sistemas Computacionais

A Modelagem e Simulação de Sistemas Computacionais permitem representar Sistemas
Computacionais por meio de modelos de simulação e reproduzir suas cadeias de causalidade,
estimar e avaliar resultados e subsidiar o processo de tomada de decisões em nível de
engenharia.
A seguir são relacionados os principais conceitos que dão suporte à modelagem e a

simulação destes sistemas.
Mais de um século de pesquisa em sistemas de filas permitem compreender a
organização dos sistemas computacionais e estabelecer suas relações físico-
Teorias da Filas
matemáticas sob a forma de Modelos Analíticos. Os seus resultados teóricos e
experimentais atestam o sucesso desta abordagem
Estatística é uma ferramenta usada quando não se sabe, ou é impossível saber,
totalmente as informações contidas em um sistema. Desta forma, ela trabalha
Estatística melhor com incertezas ao quantificá-las em níveis de confiança. Seus conceitos,
métodos e técnicas dão o suporte necessário para a validação e verificação de
experimentos envolvendo sistemas computacionais
Computadores, com sua capacidade e velocidades extremadas, dão o suporte para
a simulação. As linguagens de programação permitem escrever os softwares
Computadores, necessários para a simulação e análise de resultados. As técnicas computacionais,
Linguagem e Técnicas como estruturas de dados, programação orientada a objetos, cálculo numérico e
Computacionais computação gráfica, dão suporte à simulação. Todo e qualquer hardware ou
software, os computadores, seus componentes e seus elementos de conexão são,
eles mesmos, objetos de estudo
O acaso é um agente imprevisível e atua em todos os domínios da Natureza. Por
ser um elemento explicativo nas Ciências, é necessário introduzi-lo nos sistemas, o
Geradores de Números
que pode ser feito por meio de números aleatórios. Os geradores de números
Aleatórios e Geração
aleatórios são essenciais para gerar variáveis aleatórias e suas distribuições
de Variáveis Aleatórias
estatísticas, viabilizando a simulação computacional a partir de poucos valores
medidos, mas representativos
Modelos Analíticos de Os modelos de Sistemas Computacionais tornaram possíveis a compreensão e a
Redes de verificação de resultados de simulação discreta, extensíveis aos demais recursos
Computadores de software e de hardware
Os Sistemas Computacionais são transversais na vida das pessoas, das empresas e

dos governos. Em todas as áreas, sua influência é marcante. Sistemas de
Sistemas Computação são recursos de software e/ou de hardware, tomados em parte ou no
Computacionais todo, de modo isolado ou em rede e, para sua compreensão e seu uso adequado, é
necessário um conhecimento básico da terminologia da avaliação de desempenho,
seus princípios e suas técnicas
Com sua concisão e ubiquidade, a matemática é a linguagem que permite escrever

o corpo teórico para a modelagem, simulação discreta e análise de resultados. As
Matemática
técnicas matemáticas, como Cálculos Diferencial e Integral e Séries, são requeridas
para qualificar e quantificar as teorias deste livro e seus objetos de estudo
Cabe aqui uma ressalva, a de que variáveis aleatórias diferem das variáveis deterministas
habituais (da ciência e engenharia em geral). Variáveis deterministas apresentam um valor
único a qual associa-se um erro de medida, como a aceleração da gravidade em um ponto
deste planeta. Por outro lado, variáveis aleatórias têm seus valores associadas a distribuição
de probabilidade, que devem ser interpretados tendo em vista estatísticas de cada resultado
possível, antecipar a face de uma moeda em dado lance ou obter certa carta de um baralho.
A simulação discreta faz uso de variáveis aleatórias de modo a representar a grande

variabilidade dos seus objetos de estudo e seus usos e aplicações nas ciências e na
sociedade em geral.
Uma outra ressalva é que nossos modelos científicos são apenas modelos, simplificações,
aproximações que funcionam muito bem e, quando surge algo novo, o modelo é aprimorado.
Esse é o modo de progresso da Ciência pois ela é inacabada, em eterna construção, como
nós mesmos e a sociedade, mas busca diminuir as incertezas enquanto lida com a
complexidade deste universo material.
Visão dos Tópicos Tratados no Livro
A maioria das simulações estocásticas têm a mesma estrutura básica:
1. Identificar uma variável aleatória de interesse X e desenvolver um software para sua simulação
2. Gerar as amostras X1, ..., Xn independentes e igualmente distribuídas (iid) e com a mesma distribuição de
probabilidade
3. Estimar estatísticas de X1 e avaliar a precisão da estimativa2
A Figura 1 apresenta uma visão dos principais tópicos do livro. O tema central é a simulação
discreta, ponto de convergência de quatro outros tópicos, discutidos abaixo:
Figura 1 Esquema dos principais destaques do livro.

ramo da probabilidade que estuda a formação de filas do ponto de vista matemático, é
Teoria das Filas utilizada para estabelecer as relações físico-matemáticas dos sistemas computacionais
e permitem construir seus modelos analíticos, conceituais e computacionais
acrônimo de gerador de variáveis aleatórias, permite gerar valores para funções
GVA
densidade de probabilidade a partir dos geradores de números aleatórios (GNA)
são técnicas para comprovar se a simulação representa o sistema real com fidelidade
Validação e
suficiente para garantir a obtenção de soluções satisfatórias para o problema em nível
Verificação
de engenharia
processo que permite parametrizar, construir e reproduzir o comportamento de
Simulação
Sistemas de Fila por meio de modelos e executá-los em computadores
Para a simulação de um Sistema Computacional, o primeiro passo é a construção de um

modelo, neste caso utiliza-se modelos obtidos a partir da Teoria das Filas. Em seguida,
obtém-se amostras (medições) representativas de seu comportamento (em geral são
requeridos poucos dados). Estes dados fornecem os parâmetros que permitem identificar a
função densidade de probabilidade adequada para a amostra e, assim, gerar inúmeras
variáveis aleatórias para simulação deste sistema. Os resultados obtidos são valores médios,
desvios padrões e intervalos de confiança.
A simulação é uma técnica reducionista e sua grande vantagem é que, a partir de um modelo
de um sistema e uns poucos dados representativos deste sistema, ela permite gerar
variáveis aleatórias em grande quantidade e que são capazes de reproduzir a dinâmica deste
sistema. Atendendo bem as necessidades dos engenheiros: fazer mais com menos
atendendo aos critérios de qualidade estabelecidos.
Peço antecipadas desculpas por eventuais erros neste texto, que certamente existem,
agradeço antecipadamente toda e qualquer correção ou sugestão de melhoramentos, que
deverão ser enviadas para o e-mail da disciplina: ccmp0057@gmail.com.
1 Em geral, a média de X.
2 Em geral, intervalo de confiança.
Tabela de Símbolos
Nome3 Descrição Unidade

cpf Chegada de pacote na Fila [s]
CQ Teste χ2
D Estatística do teste χ2
DP(X) Desvio Padrão da variável aleatória X
eps Entrada de pacote no Servidor [s]
F Fila
F, fda Função distribuição acumulada, F(x)=∫f(x)dx
f, fdp Função distribuição de probabilidade
GCL Gerador Congruente Linear
GNA Gerador de Número (pseudo)Aleatório
GVA Gerador de Variável Aleatória
IC Intervalo de Confiança
ic Intervalo entre chegadas de pacotes na Fila [s/p]
iid Independente e igualmente distribuído
is Intervalo entre saídas de pacotes do Servidor [s/p]
l, λ Taxa de chegada de pacotes na Fila [p/s]
m Vetor de taxa de serviço de Servidores em RSF [p/s]
m, E[X] Esperança matemática de X, média aritmética ou valor esperado
m, μ Taxa de serviço do Servidor [p/s]
n Número de elementos de uma amostra
N Número de pacotes para simulações dos Sistemas de Fila
ℕ Conjunto dos números naturais
nf Número de pacotes na Fila
ns Número de pacotes no Servidor
nsf Número de pacotes no Sistema de Fila
p Pacote (unidade de trabalho)
p Ordem de chegada dos pacotes
p Parâmetro da distribuição de probabilidade Exponencial
p0 Probabilidade de Servidor Ocioso
r Coeficiente de correlação
r Vetor de rota de pacotes na RSF
RI Método que implementa o método de Repetições Independentes (MRI)
s Segundo (unidade de tempo) [s]
S Servidor
SF Sistema de Fila
RSF Rede de Sistemas de Fila
sps Saída de pacote do Servidor (fim do serviço) [s]
T Duração da simulação [s]
tf Tempo de espera de pacote na Fila [s]
ts Tempo de processamento de pacote no Servidor [s]
tsf Tempo de processamento de pacote no Sistema de Fila (tempo de resposta) [s]
U Utilização do Sistema de Fila
U Distribuição Acumulada Uniforme
u Variável aleatória uniformemente distribuída em [0,1]
X Amostra X = {X1, X2, ..., Xn}
X Variável aleatória
μ Esperança matemática da população
ρ Autocorrelação
σ Desvio padrão da população
3 O termo pacote será adotado neste texto para indicar as unidades recebidas, processadas e retornadas pelos Sistemas de
Fila; são sinônimos de pacote os termos tarefa, transação, trabalho, instrução, flops e operação, dentre outras denominações
encontradas na literatura da área.
Índice
1 Introdução............................................................................................................................11
1.1 Sistema.............................................................................................................................12
1.2 Modelo..............................................................................................................................13
1.3 Dinâmica Temporal de Sistemas Computacionais.............................................................15
1.4 Simulação.........................................................................................................................15
1.5 Sistemas de Fila................................................................................................................17
1.6 Simulação de Sistemas de Eventos Discretos...................................................................17
1.7 Simulação de Sistemas Computacionais...........................................................................19
1.8 Etapas de um Estudo de Simulação..................................................................................20
1.9 Revisão.............................................................................................................................22
1.10 Questões.........................................................................................................................22
1.11 Exercícios........................................................................................................................22
2 Sistemas de Fila...................................................................................................................23
2.1 Sistemas de Fila M/M/1.....................................................................................................25
2.2 Revisão.............................................................................................................................29
2.3 Questões...........................................................................................................................29
3 Modelo Analítico de Sistemas de Fila...................................................................................31
3.1 Modelo de Sistemas de Fila M/M/1....................................................................................32
3.2 Modelo Analítico de Sistemas de Fila M/M/1.....................................................................33
3.3 Revisão.............................................................................................................................35
3.4 Questões...........................................................................................................................36
3.5 Exercícios..........................................................................................................................36
4 Modelo Conceitual de Sistemas de Fila................................................................................37
4.1 Dados de Entrada para Simulação....................................................................................40
4.2 Valores Iniciais da Simulação............................................................................................43
4.3 Cálculo de cpf...................................................................................................................43
4.4 Cálculo de eps...................................................................................................................43
4.5 Cálculo de sps...................................................................................................................44
4.6 Estatísticas do Modelo Conceitual de Sistemas de Fila.....................................................45
4.7 Algoritmo para Calcular nf.................................................................................................46
4.8 Algoritmo para Calcular U.................................................................................................47
4.9 Sumário do Modelo Conceitual de Sistemas de Filas........................................................48
4.10 Revisão...........................................................................................................................50
4.11 Questões.........................................................................................................................51
4.12 Exercícios........................................................................................................................51
5 Modelo Computacional de Sistemas de Fila.........................................................................53
5.1 Técnica para Gerar ic e ts.................................................................................................54
5.2 Software SF.MM1.cpp........................................................................................................55
5.3 Revisão.............................................................................................................................61
5.4 Questões...........................................................................................................................62
5.5 Exercícios..........................................................................................................................62
6 Verificação e Validação de Modelos.....................................................................................64
6.1 Técnicas de Validação de Modelo......................................................................................65
6.2 Técnicas de Verificação de Modelos..................................................................................65
6.3 Revisão.............................................................................................................................67
6.4 Questões...........................................................................................................................67
6.5 Exercícios..........................................................................................................................67
7 Análise de Resultados Simulados.........................................................................................68
7.1 Remoção de Transientes...................................................................................................69
7.1.1 Estimação por Intervalos de Confiança..........................................................................70
7.1.2 Método das Médias de Lotes..........................................................................................72
7.1.3 Método de Replicação Independente (MRI)....................................................................73
7.2 Critério de Parada.............................................................................................................75
7.2.1 Intervalo de Confiança como Critério de Parada............................................................75
7.2.2 N como Critério de Parada.............................................................................................75
7.3 Que Nível de Confiança Estatística Usar...........................................................................76
7.4 Software SF.MM1-ML-RI.cpp..............................................................................................76

7.5 Revisão.............................................................................................................................78
7.6 Questões...........................................................................................................................78
7.7 Exercícios..........................................................................................................................79
8 Simulação de Sistemas Computacionais..............................................................................81
8.1 Modelo de Rede de Sistemas de Fila (RSF).......................................................................82
8.2 Modelo Conceitual de RSF.................................................................................................83
8.3 Valores Iniciais da Simulação de RSF................................................................................84
8.4 Roteamento do Primeiro Pacote (p=0)..............................................................................85
8.5 Roteamento dos Demais Pacotes (p>0)............................................................................86
8.6 Revisão de RSF.................................................................................................................86
9 Modelo Computacional de Redes de Sistemas de Filas........................................................87
9.1 Sistema Cliente/Servidor Web em uma Camada Física.....................................................92
9.2 Sistema Cliente/Servidor Web em duas Camadas Físicas.................................................93
9.3 Sistema Cliente/Servidor Web em três Camadas Físicas..................................................95
9.4 Simulação de Sistemas de Hardware................................................................................97
9.5 Revisão.............................................................................................................................99
9.6 Exercícios..........................................................................................................................99
10 Geração de Números Aleatórios......................................................................................100
10.1 Geradores Congruentes Lineares (GCL)........................................................................100
10.2 Aplicação do GCL..........................................................................................................101
10.3 Sementes para o GCL...................................................................................................103
10.4 GCL de uso geral...........................................................................................................103
10.5 Números Aleatórios do GNU C......................................................................................104
10.6 Composição de Geradores............................................................................................105
10.7 Geradores Tausworthe..................................................................................................106
10.8 Outros Geradores..........................................................................................................106
10.9 Classe clGNA.................................................................................................................107
10.10 Teste Empíricos de GNA..............................................................................................108
10.10.1 Testes Empíricos......................................................................................................108
10.11 Testes Teóricos............................................................................................................110
10.12 Questões.....................................................................................................................116
10.13 Exercícios....................................................................................................................116
11 Geração de Variáveis Aleatórias......................................................................................117
11.1 Método da Inversa da FDA............................................................................................118
11.2 Método da Convolução.................................................................................................119
11.3 Método da Composição.................................................................................................119
11.4 Método da Aceitação Rejeição......................................................................................119
11.5 Gerar FDA.....................................................................................................................121
11.6 Qualidade na Geração de Variáveis Aleatórias.............................................................122
11.7 Algoritmos para Gerar Variáveis Aleatórias..................................................................122
11.8 Gerar Processos de Chegada.......................................................................................125
11.9 Questões.......................................................................................................................125
11.10 Exercícios....................................................................................................................125
12 Seleção de Distribuições de Probabilidade......................................................................126
12.1 Independência de Observações....................................................................................128
12.2 Distribuições de Probabilidade Úteis.............................................................................129
12.3 Estimação de Parâmetros.............................................................................................131
12.3.1 Método da Máxima Verossimilhança..........................................................................131
12.3.2 Método dos Mínimos Quadrados................................................................................132
12.4 Estimativa dos Parâmetros das FDP..............................................................................132
12.4.1 Estimativa dos parâmetros da fdp Exponencial.........................................................132
12.4.2 Estimativa dos parâmetros da fdp Beta.....................................................................133
12.4.3 Estimativa dos parâmetros da fdp Gamma................................................................133
12.4.4 Estimativa dos parâmetros da fdp Weibull.................................................................134
12.5 Identificação da Distribuição Estatística.......................................................................134
12.5.1 Teste Chi-Quadrado (CQ)...........................................................................................135
12.5.2 Testes CQ para fdp Beta.............................................................................................137
12.6 Modelos para Processos de Chegada............................................................................137
12.7 Gerando Processos de Chegada....................................................................................138

12.8 Testando Homogeneidade de Amostras........................................................................138
12.9 Questões.......................................................................................................................140
12.10 Exercícios....................................................................................................................141
13 Recursos do C++ para a Simulação................................................................................143
14 Redução da Variância.......................................................................................................145
14.1 Números Aleatórios Comuns.........................................................................................145
14.2 Variáveis Antitéticas.....................................................................................................146
14.3 Métodos Estatísticos para Comparar Resultados Simulados.........................................149
14.3.1 Teste para Média Zero................................................................................................150
14.3.2 Observações Pareadas...............................................................................................150
14.3.3 Observações não Pareadas........................................................................................151
14.4 Questões.......................................................................................................................152
14.5 Exercícios......................................................................................................................153
15 Softwares para Simulação Sistemas de Fila.....................................................................155
15.1 Dicionário de Dados dos Softwares...............................................................................155
15.2 SF.MM1.cpp...................................................................................................................156
15.3 SF.MM1-ML-RI.cpp.........................................................................................................159
15.4 RSF.MM1.cpp.................................................................................................................162
15.5 RSF.MM1-ML-RI.cpp.......................................................................................................165
16 Modelo Analítico de Sistemas de Fila M/M/1....................................................................169
17 GVA pelo Método da Inversa............................................................................................171
17.1 GVA da Distribuição de Probabilidade Exponencial.......................................................171
17.2 GVA da Distribuição de Probabilidade de Valores Extremos.........................................172
17.3 GVA da Distribuição de Probabilidade Logística............................................................172
17.4 GVA da Distribuição de Probabilidade de Pareto...........................................................173
17.5 GVA da Distribuição de Probabilidade Weibull..............................................................173
18 Referências......................................................................................................................175
1 INTRODUÇÃO
Os Sistemas Computacionais prestam relevantes serviços e compartilham recursos em vários

níveis na atualidade, sendo cada vez mais necessários, mais complexos, mais abrangentes e
mais presentes.
Devido a sua grande importância e alcance espaço-temporal, é necessário a avaliação destes

sistemas via medição, emulação, simulação e modelagem. Dentre estas metodologias,
destaca-se a simulação por ser uma abordagem empírica/matemática que permite, não só o
entendimento destes sistemas, mas também estimar o melhor uso destes recursos.
Para representar a diversidade dos Sistemas Computacionais são necessários variados

parâmetros relacionados ao seu desempenho, o conceito de Sistema de Filas, apesar da sua
simplicidade, é a ideia primária para a compreensão do mais simples ao mais complexo
Sistema Computacional, da performance de uma CPU à grande rede mundial – a Internet, dos
sistemas de hardware e dos sistemas de software.
Os Sistemas de Filas são utilizados para a modelagem analítica, simulação e avaliação do

desempenho de sistemas computacionais, tanto em nível de software quanto de hardware.
Estes modelos permitem descrever o estado destes sistemas quantificando suas variáveis de
estado e sua dinâmica temporal.
A Simulação de Sistemas Computacionais pode ser vista como o estudo do comportamento

de sistemas através de modelos de filas. Ela utiliza outras áreas do conhecimento,
principalmente estatística, mas também números aleatórios, matemática discreta, teoria dos
números e técnicas de programação, além de engenharia de software, cálculo numérico e
computação gráfica.
O uso da Simulação Discreta pode oferecer vantagens quando é necessário estimar

distribuição de variáveis aleatórias, comparar cenários representando diferentes soluções de
um problema, avaliar o comportamento de uma solução e avaliar projetos de software e
hardware.
A Simulação Discreta utiliza linguagens de programação para implementar os modelos
matemáticos de sistemas computacionais e processá-los em computadores, fazendo uso das
capacidades e velocidades extremadas destas máquinas.
A execução de modelos de Simulação Discreta em computador tem potencial para fornecer
resultados mais precisos sem a necessidade de interferir nos sistemas reais, possibilitando
gerar informações úteis na tomada de decisões para a solução de problemas.
A Simulação Discreta é um instrumento com grande potencial de aplicação comercial, na

pesquisa e em consultoria, principalmente em redes e suas aplicações, um campo em grande
crescimento. Mas vai além, como banco de dados, sistemas operacionais, sistemas
embarcados, projetos de hardware e software e gestão de recursos. Bem como na gestão de
recursos de sistemas multimídia, Computação em Nuvem, Internet das Coisas (IoT),

Domótica, Cidades Inteligentes, dentre outras áreas emergentes.
A seguir serão apresentados os conceitos de sistema, modelo e simulação, nesta ordem.

Estes termos estão relacionados, como visto abaixo.
1.1 Sistema
O mundo real é de elevada complexidade e de difícil acesso, a sua compreensão é analítica,

ou seja, a sua compreensão é feita por partes. Estas partes são chamadas de sistemas. A
ideia de sistema é aplica em várias áreas do conhecimento. Na engenharia pode-se entender
sistemas como partes do mundo real – algo concreto; pode-se ainda entendê-lo como
projetos – uma representação físico-matemática que tem realidade no mundo das ideias.
O termo sistema pode ser definido como um conjunto estruturado de componentes entre os
quais pode-se definir alguma relação de funcionalidade seus elementos constituintes. O valor
dos atributos dos seus componentes, variáveis de estado e parâmetros, em um dado instante
de tempo, define o estado do sistema, Figura 1.1.
Figura 1.1 Representação gráfica da relação sistema e o mundo real.
Para os propósitos deste livro, os sistemas de interesse são os Sistemas Computacionais, que
são sistemas orientados a eventos de entrada, processamento e saída, constituídos por
recursos de software e de hardware, tomados em parte ou no todo, de modo isolado ou em
conjunto. Nosso estudo é focado em Sistemas de Fila para representar Sistemas
Computacionais, pois são capazes de reproduzir estas estruturas e seu comportamento.
Exemplo 1.1 O circuito TTL 7400 da Figura 1.2 é um exemplo de um sistema, um dispositivo que contém quatro
portas NAND, cada uma delas com duas entradas e uma saída. As portas são independentes; suas variáveis de
estado são os valores das entradas e saída e seus parâmetros são os dados do fabricante.
Fonte: https://materialpublic.imd.ufrn.br/curso/disciplina/1/17/3/7
Figura 1.2 Circuito integrado TTL 7400, um sistema do mundo computacional.
Os Sistemas de Fila são sistemas gerais e orientados, conforme apresentado abaixo.

Exemplo 1.2 Sistema Orientado
O primeiro passo na aplicação do conceito de sistema a um problema específico é definir o que constitui o
sistema. Um segundo ponto a ser considerado, é a escolha do nível de descrição desejado.
O conceito de sistema geral pode ser considerado como o menor nível de descrição de um sistema em que
somente as possíveis interações com o mundo exterior são retidas, ficando definida sua constituição e aquilo
que lhe é externo. Um sistema geral é definido por um conjunto de relações entre as entidades que
caracterizam as interações com o mundo exterior.
Assim. sistema geral é uma relação entre as variáveis que ligam um sistema ao mundo exterior. Se forem
definidas as variáveis usadas como excitação (entrada) e as variáveis usadas como resposta (saída), tem-se
um sistema orientado. Um sistema orientado, pode ser caracterizado por uma relação entre o conjunto de
entradas e saídas.
Os conceitos de sistemas geral e orientado não incluem o tempo como intrínseco ao sistema, e as entradas e
saídas são tratadas como eventos.
1.2 Modelo
Modelos são descrições de um sistema, concebidos através de uma abstração da realidade

considerando seus aspectos relevantes, para permitir uma análise simplificada sem descartar
seus aspectos importantes.
A construção de um modelo, em geral, busca viabilizar a solução de um problema de um

sistema, podendo existir um número variado de modelos para um mesmo sistema, cada um
deles considerando aspectos específicos do mesmo.
A utilidade de um modelo está diretamente relacionada à sua capacidade de incorporar

elementos reais de forma simples, contendo seus aspectos importantes sem que a sua
complexidade impossibilite a compreensão e manipulação do mesmo, Figura 1.3.
Figura 1.3 Representação gráfica da relação mundo real, sistema e modelo.
Para os propósitos deste livro, os modelos de interesse são os modelos de Sistemas de Fila,
que são modelos matemáticos capazes de representar os processos de Sistemas
Computacionais de modo geral, simular seu comportamento, descrever seus aspectos
relevantes, permitir sua análise e fazer predição de seu comportamento.
O Modelo de Sistemas de Fila tem uso prático (valor de uso), tem predicabilidade (valor
preditivo), representa os sistemas computacionais (valor de face) e permite construir
modelos computacionais (valor de simulação), enfim, é útil para os fins propostos.
Exemplo 1.3 A Figura 1.4 é um modelo do circuito TTL 7400, com suas quatro portas NAND, cada uma delas
com duas entradas e uma saída.. Pode-se verificar que os elementos desnecessários para caracterização do
sistema da Figura 1.2 foram propositalmente abstraídos, restando tão somente aqueles que são relevantes e
úteis para os propósitos da eletrônica digital. Note que foram adicionados símbolos pictóricos ao modelo, que
são necessários à sua manipulação.
Fonte: https://materialpublic.imd.ufrn.br/curso/disciplina/1/17/3/7
Figura 1.4 Um modelo do circuito integrado TTL 7400.
Desafios
1. Na música Minha História, de Chico Buarque, tem o verso: “Com seu único velho vestido cada dia mais
curto”. Considerando este verso, identifique e relação causa/efeito e faça um modelo matemático para
quantificar esta relação.
2. Encontre o modelo matemático implícito no texto bíblico: “a quem tem, mais será dado, mas a quem não
tem, até o que tiver lhe será tirado”.
O exemplo a seguir mostra o poder dos modelos.
Exemplo 1.4 Os 6 números que definem todo o Universo
O professor de física Lyman Page explica como nosso modelo de Universo é baseado apenas
em seis parâmetros. Todas as evidências e teorias baseadas em observações do universo
podem ser reunidas em um modelo padrão de cosmologia que tem apenas seis parâmetros.
Como estudamos o Universo como um todo?
Meu trabalho se concentra na radiação cósmica de fundo em micro-ondas (CMB, na sigla em

inglês) — os tênues resquícios de energia do Big Bang — e como medi-la pode guiar nosso
caminho para a compreensão do Universo.
Mas há muitas outras maneiras de estudar o cosmos, e os físicos que o fazem se

especializam em tudo, desde a relatividade geral até a termodinâmica e a teoria das
partículas elementares.
Fazemos observações em quase todos os regimes de comprimento de ondas acessíveis para

medição e com detectores de partículas de última geração.
As observações provêm de lugares próximos e dos confins mais distantes do espaço.
Todas essas evidências e teorias podem ser reunidas em um modelo padrão

surpreendentemente simples de cosmologia, que tem apenas seis parâmetros.
O primeiro parâmetro descreve a quantidade de matéria normal, átomos, no Universo, e diz

que eles representam apenas 5% do Universo.
O segundo parâmetro descreve a matéria escura, um tipo de partícula elementar nova que
ainda não entendemos, que representa 25% do Universo.
O terceiro parâmetro é a constante cosmológica, a misteriosa energia escura que está na

raiz da expansão acelerada do Universo.
O quarto parâmetro é a profundidade óptica, ou quão opaco o Universo era para os fótons
que viajam por ele.
O quinto e o sexto parâmetros descrevem as origens das diminutas flutuações que deram
origem a toda a estrutura que observamos hoje no Universo.
Em suma, não importa como olhamos para o cosmos — por meio de sondagens de galáxias,
de estrelas em explosão, da abundância de elementos de luz, das velocidades das galáxias
ou da CMB —, nós só precisamos de todos os seis parâmetros explicados acima, e processos
físicos conhecidos, para descrever o Universo que observamos.
O que significa ser capaz de descrever algo de forma tão simples e quantitativa? Significa
que entendemos como as peças do Universo se encaixam para formar o todo. Entendemos
algumas conexões profundas na natureza.
Há poucos sistemas estudados por cientistas que podem ser descritos de forma tão simples,
completa e com tanta precisão. Temos sorte de o Universo observável ser um deles.
Extraído em 07/03/2021 de: https://www.bbc.com/portuguese/geral-55936974
1.3 Dinâmica Temporal de Sistemas Computacionais
O circuito TTL 7400 da Figura 1.4 será usado para representar da dinâmica temporal de um
Sistema Computacional, suas variáveis de estado (valor das entradas e saída) e parâmetros
(dados do fabricante). Neste caso, sinais entram nas portas lógicas, são processados e
enviados para as saídas.
Uma característica importante dos sinais, é que não se sabe quando chegarão. Suas
chegadas ocorrem ao acaso, é uma variável aleatória.
Uma vez que o sinal chegou, ele é processado. Cada porta lógica tem uma taxa de
processamento, um dos seus parâmetros de fábrica. A combinação dos valores de entrada,
em número de quatro, e as variações no sincronismo das duas chegadas podem gerar
diferentes demandas de processamento e, como não se sabe que valores de entrada
chegarão e como estão sincronizados, a taxa de processamento também é aleatória.
Generalizando estas ideias, os Sistemas Computacionais recebem tarefas para serem

processadas. Eles são caracterizados por duas grandezas, a taxa de chegada e a taxa de
processamento. Estas taxas dão origem a duas outras grandezas temporais, o tempo entre
as chegadas e o tempo de processamento. Estes tempos, em geral, são variáveis aleatórias,
o tempo entre chegadas depende do acaso, e o tempo de processamento depende do
tamanho da tarefa que chega, que são aletórios.
Exemplo 1.5 Outras grandezas, derivadas do tempo entre as chegadas e o tempo de processamento, permitem
a tomada de decisão em nível de engenharia, quais sejam:
• Vazão ou Throughput: é o número de tarefas executados em um determinado intervalo de tempo.

Quanto maior a vazão, maior o número de tarefas executadas em função do tempo. A maximização da
vazão é desejada na maioria dos sistemas.
• Tempo de Processamento: é o tempo que uma tarefa leva para ser processada. Este parâmetro
depende do sistema em uso e da tarefa.
• Tempo de Espera: é todo o tempo que a tarefa permanece aguardando para ser processada. A
redução deste tempo de espera é desejada de modo geral.
• Tempo de Resposta: é o tempo decorrido entre uma requisição ao sistema e o instante em que a
resposta começa a ser informada.
Estas grandezas, dentre outras, são objeto de estuda da Simulação de Sistemas Discretos.
1.4 Simulação
A simulação permite reproduzir o comportamento dos sistemas, utilizando modelos de

sistema reais que são representações do sistema e suas conexões com o mundo real, no qual
está inserido e interage, como mostrado na Figura 1.5. Por meio dela, pode-se manipular um
modelo de um sistema, real ou hipotético, para compreender seu comportamento ou avaliar
sua operação, descrever seus aspectos relevantes, permitir sua análise e fazer predição.
Figura 1.5 Representação gráfica da relação mundo real, sistema, modelo e simulação.
Uma das grandes utilidades da simulação é tornar possível fazer estimativas do

comportamento de um sistema, além de estabelecer como mudanças no sistema podem
afetar seu comportamento e desempenho, ou seja, a análise de sensibilidade de modelos.
Suas aplicações são amplas e podem focar tantos nas Ciências quanto nas Engenharias. Nela
podem ser enfatizados aspectos tecnológicos como projetos, protótipos e inovação; e bom
como os científicos e econômicos. Incluiriam também alguns os aspectos sociais.
A simulação pode ser classificada de várias maneiras, a mais comum usa quatro categorias:
a) simulação contínua; b) simulação Monte Carlo; c) simulação de eventos discretos e d)
simulação baseada em trace.
Um processo pode ser de estado discreto ou contínuo. Se os valores que suas variáveis de
estado podem assumir é finito e enumerável, o processo é chamado de processo de estado
discreto. Por exemplo, o número de pacotes em um sistema de fila pode ter valores discretos
iguais a 1, 2, 3 e assim por diante, portanto, a formação de filas é um processo de estado
discreto.
Por outro lado, se as variáveis de estado podem assumir qualquer valor real ele é um
processo de estado contínuo. O tempo de espera numa fila, teoricamente, pode assumir
qualquer valor real é, portanto, um processo de estado contínuo. Já o processo de chegada
na fila é discreto, não ocorre continuamente, ocorre em momentos sucessivos do tempo.
A simulação contínua é utilizada para modelar sistemas cujo estado varia continuamente no
tempo, sendo comum a utilização de equações diferenciais. A simulação discreta usa
modelos sistemas cujo estado varia de modo discreto no tempo, utiliza o conceito de
eventos.
O Método de Monte Carlo é um método estatístico que utiliza amostragens aleatórias

massivas para obter resultados numéricos, repetindo sucessivas simulações para calcular
probabilidades. Tem sido utilizado como forma de obter aproximações numéricas de funções
complexas, utilizando alguma distribuição de probabilidade e uma amostra para aproximar a
função de interesse. Simulação de Monte Carlo é um modelo de simulação estática, a
passagem do tempo é irrelevante.
Trace ou Rastreio é um registro cronológico de eventos ocorridos em um sistema real, como

um log (lista ordenada de eventos de tempo e suas variáveis associadas)de um sistema
operacional ou o registro de um monitoramento. A simulação baseada em trace utiliza este
registro como dados de entrada e, assim, permite avaliar o comportamento do sistema e
seus modelos. Eles podem ser apresentados em vários níveis de detalhe: eventos de
rastreamento, procedimento trace ou rastreio de variáveis.
Traces são úteis para conhecer o comportamento de sistemas computacionais, são fontes de
dados para obtenção de funções de distribuição de probabilidade de dados para uso em
simulação. Como são valores medidos, podem também ser usados na validação e verificação
de resultados de simulações. Para serem úteis e ter valor estatístico, traces devem ser
amostras representativas do comportamento do sistema.
Os sistemas discretos são constituídos por sequência de eventos discretos no tempo. Cada
evento ocorre em um determinado instante de tempo e marca uma mudança de estado no
sistema. Entre eventos consecutivos, o sistema não muda 4 e a simulação pode ser feita de
evento em evento, sequencialmente, do início ao fim.
A Teoria da Filas é o modelo matemático usado para representar Sistemas Computacionais,

ela é um ramo da probabilidade que estuda a formação de filas. Este modelo matemático
demonstra o comportamento de um sistema de oferta de serviços com demanda aleatória,
envolvendo clientes e provedores de serviços.
A simulação de eventos discretos consiste em processar eventos consecutivos que ocorrem

em Sistemas de Filas, evento a evento, sequencialmente no tempo, do início ao fim; e
produzir resultados operacionais de qualidade por meio de estatísticas das suas propriedades
mensuráveis.
4 As mudanças que ocorrerem não afeta o comportamento do modelo do sistema e nem seus resultados.
1.5 Sistemas de Fila
Os Sistemas de Fila são modelos matemáticos da Teoria da Filas usados para representar
Sistemas Computacionais.
Os Sistemas de Fila são descritos por seis parâmetros, utilizando a notação de Kendall
(A/S/m/K/N/Q em que A – distribuição dos tempos entre as chegadas, S – distribuição dos
tempos de serviço, m – número de servidores, K – capacidade do sistema, N – tamanho da
população, e Q – disciplina de atendimento).
Os Sistemas de Fila podem possuir diferentes estruturas e configurações e, por simplicidade,

mas sem perder o rigor conceitual, será considerado os Sistemas de Fila mais simples –
aqueles constituídos por uma Fila e um Servidor. De modo geral o termo Pacote5 denomina
as unidades de trabalho dos Sistemas de Fila. Este modelo básico atende às necessidades
acadêmicas e é capaz de explicar o comportamento de um sistema de oferta de serviços com
demanda aleatória, envolvendo pacotes em uma fila e um provedor de serviços.
Um Sistema de Fila (SF) simples é constituído por:
1. uma única Fila (F)
2. um único Servidor (S)
3. juntos, a Fila e o Servidor, definem o Sistema de Fila (SF)
4. a demanda é caracterizada pela chegada de clientes na Fila, a taxa de chegada
5. a oferta é caracterizada pela capacidade de processamento do Servidor, a taxa de

serviço
6. seus eventos são: chegada de pacotes na Fila, entrada de pacotes no Servidor e saída
de pacotes do Servidor
A dinâmica do SF, que determina seu comportamento, é feita por simulação dos seus
eventos, que são discretos no tempo.
1.6 Simulação de Sistemas de Eventos Discretos
Os modelos de Simulação de Eventos Discretos (SED) mais simples possuem uma única Fila e
um único Servidor. Cada pacote possui três atributos: tempo de chegada no sistema, tempo
de entrada no servidor e tempo de saída do servidor. O estado do sistema é definido pelo seu
fluxo de pacotes; e o estado dos pacotes é definido pelos seus atributos.
O objetivo de um modelo de simulação de eventos discretos é representar o fluxo de pacotes

através de um sistema, atribuir valores aos eventos dos pacotes e, assim estabelecer o
comportamento e o desempenho deste sistema.
O fluxo de pacotes nos SEDs é caracterizado pela chegada, processamento e partida de

pacotes. O fluxo de cada pacote através do SED é caracterizado por:
1) chegar no sistema
2) entrar na Fila
3) aguardar na Fila, se necessário
4) entrar no Servidor
5) ser processado no Servidor
6) sair do Servidor
5 O termo pacote é adotado neste texto para indicar as unidades operacionais dos Sistemas de Fila; são sinônimos de
pacote termos: tarefa, transação, requisição e instrução. Outras denominações para pacote são encontradas na literatura
técnico-científica.
O estado do SED muda em três situações, que podem ocorrer de forma isoladas ou
conjuntas. A primeira situação é quando o pacote chega na Fila. A segunda é quando o
pacote entra no Servidor. A terceira situação é quando o pacote sai do Servidor.
As mudanças de estado dos SED são imprevisíveis pois ocorrem ao acaso. São três eventos
discretos aleatórios no tempo cronológico, a saber:
1) chegada do pacote na fila – o pacote entra no sistema de fila

2) entrada do pacote no servidor – o pacote sai da fila e entra no servidor
3) saída do pacote do servidor – o pacote sai do sistema de fila
A Figura 1.6 ilustra o fluxo de pacotes, eventos e tempos dos eventos em Sistema e Eventos
Discretos. Vale ressaltar que o fluxo de pacotes é a variável independente e que o tempo é
variável dependente.
Figura 1.6 Fluxo de pacotes, eventos e tempos dos eventos em Sistema e Eventos Discretos;
o eixo do tempo na vertical indica que ele é variável dependente.
Variáveis de estado derivadas dos eventos discretos:
a) número de Pacotes na Fila

b) condição do Servidor (ocioso/ocupado)
c) tempo de ocupação do Servidor
d) condição de Pacote (na Fila/no Servidor)
e) tempo de espera de Pacotes na Fila
f) tempo de processamento de Pacotes no Servidor
g) duração da simulação
Exemplo 1.6 Modelagem e Simulação

Sistemas Computacionais são constituídos por dispositivos de hardware e software. O
hardware corresponde às partes eletrônicas e mecânicas que possibilitam a existência do
software e a interação com o usuário. O software fornece as interfaces para que usuários
executem suas tarefas. Estes sistemas realizam atividades humanas, ou de outros sistemas
computacionais, por meio do processamento de tarefas. Os Sistemas Computacionais são
caracterizados, grosso modo, pelos elementos: hardware, software, usuários e tarefas.
A importância dos Sistemas Computacionais reside no seu conjunto de capacidades e

comportamentos, as quais caracterizam seu desempenho em nível operacional. A simulação
destes sistemas no âmbito das engenharias pode ser realizada tanto por medição quanto
por meio da modelagem matemática. A partir de um modelo matemático aceitavelmente e
representativo de um sistema, pode-se aplicar técnicas matemáticas para descrever o seu
comportamento e também estimar sua performance comparada a indicadores previamente
estabelecidos.
A relevância da Modelagem e Simulação reside na sua abrangência cada vez maior. A

interação entre pessoas, empresas e governos, mediada pela tecnologia tanto em nível local
quanto global, é um novo estímulo para mudanças sociais e econômicas, promovendo cada
vez mais a produção de riqueza; além de ser o suporte para a criação de conhecimento com
a aplicação da Inteligência Artificial, Ciência dos Dados e Internet das Coisas, dentre outras
áreas aplicadas.
1.7 Simulação de Sistemas Computacionais
A Simulação de Sistemas Computacionais faz uso da Simulação de Eventos Discretos, o

modelo usado é o Sistema de Filas, que é constituído de Filas e Servidores. Neste sistema, os
Pacotes entram numa Fila e são atendidos por um Servidor. Os processos de chegar na Fila,
entrar no Servidor e sair do Servidor são eventos discretos visto que ocorrem em pontos
isolados do tempo, Figura 1.7. No eixo X desta figura é mostrada uma sequência de três
pacotes e seus respectivos eventos discretos no eixo Y: chegar na Fila, entrar no Servidor e
sair do Servidor.
Figura 1.7 Sequência de três Pacotes e seus respectivos eventos discretos: chegar na Fila (∎),
entrar no Servidor (∎) e sair do Servidor (∎).
Pode-se ver que, na Figura 1.7, o eixo X, da variável independente, refere-se a Pacotes que
chegam ao sistema sucessivamente. Já o eixo Y, da variável dependente, é o tempo e os
respectivos eventos discretos de cada Pacote: tempo de chegada na Fila, tempo de entrada
no Servidor e tempo de saída do Servidor.
Um evento discreto acontece em um momento do tempo. Neste caso, o tempo deixa de ser a
variável independente. Como o estado de um Pacote no sistema (na Fila ou no Servidor)
permanece constante entre os eventos, uma descrição completa do estado do sistema pode
ser obtido inserindo e processando Pacotes sucessivamente no sistema.
A simulação de sistemas computacionais consiste em representar estados de Sistemas de

Filas, fazer passar por eles uma sequência de Pacotes, quantificar os tempos de ocorrência
dos eventos discretos de cada Pacote e produzir resultados operacionais de qualidade por
meio de estatísticas.
1.8 Etapas de um Estudo de Simulação
O processo de construção de modelos para representar sistemas pode ser organizado em

uma sequência de estágios, discutidos na Tabela 1.1, segundo Jain (1991).
Tabela 1.1 Estágios da construção de modelos para simulação de sistemas

Identificação do Problema
o problema é discutido no escopo do sistema real ou seu projeto. Uma vez identificado o problema, pode-se
avaliar a viabilidade do uso da simulação para sua solução. Esta avaliação acontece em consonância com os
objetivos da simulação e dos seus usuários finais
Formulação do Problema
após identificado, o problema é então formulado com vistas à simulação. Devido à natureza evolucionária da
modelagem e da simulação, a definição do problema é um processo contínuo, que ocorre em todos estes
estágios
Objetivos
consiste em identificar claramente os resultados a serem alcançados com a simulação, definir critérios para
avaliação destes resultados e apresentar suas aplicações, restrições e limites das soluções encontradas para o
problema. Em seguida são definidos os objetivos específicos, para enumerar as características internas do
sistema que precisam ser representadas no modelo
Construção do Modelo Conceitual
o modelo conceitual consiste de uma descrição estática e de uma descrição dinâmica. A descrição estática
define os elementos do sistema e suas características. A descrição dinâmica define o modo como estes
elementos interagem causando mudanças no seu estado no decorrer do tempo dos eventos. O modelador
deve conhecer bem a estrutura e as regras de operação do sistema e saber extrair o essencial do mesmo, sem
incluir detalhes desnecessários. A quantidade de detalhes incluída no modelo deve ser baseada no propósito
para o qual é construído
Determinação dos Dados de Entrada e Saída
geralmente os valores de entrada são, de início, hipotéticos ou baseados em alguma análise preliminar.
Dependendo do objetivo do modelo, amostras representativas do problema são requeridas e são úteis nos
estágios posteriores do estudo da simulação. Dados da literatura, como dados do fabricante (datasheets) e
artigos técnicos e científicos, são fontes de dados usuais
Construção do Modelo Computacional
é a tradução do modelo conceitual para uma forma reconhecida pelo computador
Verificação
consiste em determinar se o modelo conceitual é executado pelo computador como esperado
Validação
busca comprovar que o modelo conceitual representa o sistema real com fidelidade suficiente para garantir a
obtenção de soluções satisfatórias para o problema. Normalmente são utilizados cenários em que o
comportamento real já é conhecido previamente e que pode ser comparado com o comportamento obtido com
a simulação. Também pode envolver uma comparação da estrutura do modelo e do sistema, e comparações do
número de vezes que decisões fundamentais ou pacotes dos subsistemas são realizadas. Outros modelos do
mesmo sistema também podem ser utilizados na validação
Plano de Tática e Estratégia
refere-se ao estabelecimento das ações para a execução da simulação, o plano estratégico consiste em um
cronograma de atividades eficiente tanto para explicar as relações entre os resultados simulados e as variáveis
controladas, quanto para determinar a combinação dos valores das variáveis controladas que minimizariam ou
maximizariam a resposta simulada. Já o plano tático consiste em determinar como cada simulação deve ser
realizada para se obter as informações desejadas sobre os dados
Experimentação e Análise dos Resultados
execução do modelo computacional, interpretação e análise dos resultados
Implementação dos Resultados
os resultados da simulação são implantados no sistema real e devem ser monitorados para comparar
resultados da simulação com os resultados operacionais e fazer avaliações em nível de campo
Documentação do Modelo
documentação do modelo utilizando os diagramas da UML ou equivalente
Relatório da Simulação
relatório técnico da simulação e memória de cálculo utilizando normas técnicas ou equivalente
O seguinte exemplo trata dos modelos matemáticos.

Exemplo 1.7 Por que confiamos em modelos matemáticos?
Marcelo Girardi Schappo
Quanto tempo leva para ir de carro de São Paulo ao Rio de Janeiro? Depende da velocidade do automóvel,
certo? Quanto mais rápido nos movermos, menos tempo levaremos para chegar ao destino. Na escola, muita
gente aprendeu uma relação chamada de “velocidade média”, que é a razão entre a distância e o tempo
necessário para percorrê-la. Usando essa equação, podemos estimar a velocidade média de um carro, de um
ônibus ou de um avião. Se, ao contrário, soubermos a velocidade média, podemos usar a mesma equação para
determinar, aproximadamente, o tempo da viagem. Fazendo isso, estamos, na verdade, usando um modelo
matemático simples (a definição matemática da velocidade média) para tentar prever determinado fenômeno
(tempo de viagem de São Paulo ao Rio).
Essa é a grande importância dos “modelos” na ciência. Eles permitem fazer previsões sobre determinados
fenômenos e processos. No caso da viagem, quanto melhor for a nossa estimativa inicial para a velocidade
média, melhor será a previsão sobre o tempo do percurso. Para estimarmos da melhor forma possível esse
valor, precisamos levar em conta um conjunto grande de parâmetros, como a possibilidade de haver
congestionamentos, acidentes, paradas para descanso, trechos de subida ou descida, e assim por diante.
Como não conseguimos ter certeza sobre todos esses parâmetros, nossa previsão de tempo de viagem, obtida
pelo modelo, sempre terá uma margem de erro. Em outras palavras, toda modelagem possui algum grau de
simplificação. A natureza é difícil demais.
Ao longo da história, cientistas têm tentado driblar essas dificuldades fazendo modelos cada vez mais
robustos, e temos tido bastante sucesso. Veja que, atualmente, uma sonda lançada para outro astro do
sistema solar terá seu caminho traçado com bastante precisão. É possível saber, de antemão, o dia e a hora da
chegada ao destino final.
Os modelos são tão importantes que estão por toda a parte na ciência. Podemos usar modelos matemáticos
em astrofísica, por exemplo, para estudar o comportamento futuro de um sistema de milhares de estrelas e
centenas de galáxias. Como esses corpos se comportarão no futuro? Quantos colidirão, ou se fundirão?
Quantos serão ejetados para fora de seus sistemas? E quanto tempo esse processo vai levar?
Podemos também fazer previsões acertadas sobre a forma correta de produzir um circuito elétrico num
aparelho de rádio capaz de transmitir e receber sinais eletromagnéticos, sustentando adequadamente as
comunicações, por exemplo. Usamos modelos para fazer a previsão do tempo pra amanhã e para estimar
cenários futuros para o clima do planeta. Também é possível usar modelos para reações químicas para tentar
entender como elas ocorrem. Em uma sala de raios-X, podemos usar modelos que nos auxiliam a determinar a
proteção adequada para diminuir a exposição do operador da máquina à radiação. Os exemplos são
incontáveis.
Sim, a natureza é complicada, e os modelos são simplificações. Mas essas simplificações, embora inevitáveis,
não tornam o processo pouco importante ou inútil, como todos esses exemplos demonstram. Modelar a
natureza é um dos grandes trunfos da humanidade, por meio da ciência.
À medida que vamos aprendendo mais e obtendo mais dados, cientistas que trabalham com os modelos da
área estão de prontidão para implementar esses dados e atualizar as previsões. Esse é o poder da ciência.
Adaptado de: Schappo, Marcelo Girardi. Por que confiamos em modelos matemáticos? Revista Questão de
Ciência. 2020. Disponível em: <https://www.revistaquestaodeciencia.com.br/questionador-questionado/
2020/04/09/por-que-confiamos-em-modelos-matematicos>. Acesso em: 9 Abr 2020.
1.9 Revisão
(a) (b)
Figura 1.8 a) Simulação e seus conceitos e b) Modelo de Sistemas Computacionais.
O objetivo é associar os dois conceitos para Simular Sistemas Computacionais por

computadores.
1.10 Questões
1. Relacione as perguntas abaixo com os estágios da construção de modelos para simulação de sistemas
da Tabela 1.1, justificando sua resposta:
a) Como se relacionam os resultados com os objetivos?
b) Por que o problema está sendo estudado?
c) Quais são as hipóteses e pressupostos?
d) Quais serão as respostas que o estudo espera alcançar?
2. Relacione as Figura 1.8-a e Figura 1.8-b.
3. Faça uma única figura representando as Figura 1.8-a e Figura 1.8-b.
4. Faça um resumo do texto do Exemplo 2.2 com até 1000 caracteres?
5. Crie 7 palavras-chaves para o texto do Exemplo 2.2?
6. Relacione a Figura 1.7 com o texto do Exemplo 2.2.
1.11 Exercícios
1. Uma caixa d’água cúbica de aresta 2 m recebe água na taxa de 2 L/s. Faça um modelo matemático para
calcular o volume de água na água em função do tempo.
2. Uma caixa d’água, de formato cônico equilátero, recebe água na taxa x L/s. Faça um modelo matemático
para calcular o volume de água na água no cone em função do tempo.
3. Dois automóveis, em uma estrada, distam L m um do outro. Faça um modelo matemático para descrever
a trajetória destes veículos, sabendo que um tem o dobro da velocidade do outro. Quando eles se
encontram?
4. Que suposições e simplificações foram necessárias para modelar os problemas anteriores e resolvê-los?
5. Aplicar as etapas do processo de construção de modelos nos problemas anteriores.
6. Aplicar as etapas do processo de construção de modelos na Pilha de Execução de Programas C (Heap,
Stack, Global, Program Code).
7. Aplicar as etapas do processo de construção de modelos na Linguagem SQL (DDL, DML, DCL).
2 SISTEMAS DE FILA
Os Sistemas de Fila são as unidades básicas da Simulação Discreta de Sistema

computacionais. Sistemas de Fila podem ser descritos como pacotes chegando para serem
processadas e saindo do sistema após serem atendidas. A formação de Fila ocorre quando a
procura é maior do que a capacidade de atendimento do Servidor. O fluxo temporal dos
pacotes, chegando nas Filas, chegando e saindo dos Servidores, determina a dinâmica do
Sistemas de Fila e seus eventos ao processar pacotes.
Em termos conceituais, Sistemas de Fila são compostos por uma ou mais Filas e por um
ou mais Servidores, como exposto na Tabela 2.1. O Pacote é a unidade que requer
atendimento.
Tabela 2.1 Componentes dos Sistemas de Fila

Pacote unidade que requer atendimento
representam os pacotes que esperam atendimento, não inclui os pacotes sendo atendidos nos
Filas
Servidores
Servidores canais que realizam atendimento dos pacotes das Filas
A Figura 2.1 representa graficamente a estrutura de um Sistema de Fila, nela pode-se ver
seus componentes, suas inter-relações e seus parâmetros. Nesta figura estão identificados
seis parâmetros básicos dos Sistemas de Fila, que são descritos na Tabela 2.2: 1) processo de
chegada; 2) distribuição do tempo de serviço; 3) número de Servidores; 4) capacidade do
Sistema; 5) tamanho da população; 6) disciplina de Serviço.
Figura 2.1 Representação gráfica de um Sistema de Fila única com múltiplos servidores, sua
estrutura, parâmetros básicos e inter-relações entre seus componentes (Jain, 1991).
Tabela 2.2 Os seis parâmetros básicos dos Sistemas de Fila

Parâmetro Descrição
o processo de chegada de pacotes ou entrada de pacote na Fila do sistema, é medido
1. Processo de chegada em termos de número médio de pacotes que chegam por unidade de tempo (λ – taxa
média de chegada) ou pelo tempo médio entre chegadas sucessivas de pacotes (1/λ)
2. Distribuição do tempo a distribuição do tempo de serviço é descrito pela taxa de serviço (μ) ou tempo de
de serviço atendimento de um pacote (1/μ)
número de servidores que prestam serviços simultaneamente. Um sistema de filas
3. Número de Servidores pode possuir um ou múltiplos canais de atendimento operando independentemente
um do outro.
número máximo de pacotes permitidos no sistema ao mesmo tempo, tanto aqueles
4. Capacidade do Sistema
sendo atendidos quanto aqueles nas filas
5. Tamanho da população tamanho potencial da população de pacotes que demandam o sistema
refere-se à maneira como os pacotes são escolhidos para entrar no servidor após a
6. Disciplina de Serviço
fila ser formada
Os seis parâmetros dos Sistemas de Fila, apresentados na Figura 2.1 e na Tabela 2.2, são
resumidos pela Notação de Kendall através dos símbolos A/B/c/K/m/Z, descritos na Tabela
2.3.
Tabela 2.3 Descrição dos parâmetros da notação de Kendall para Sistemas de Fila e valores
dos seus parâmetros
Símbolo Descrição Valores
distribuição estatística dos intervalos de M – Processo de Markov (os pacotes chegam e
A
tempo entre chegadas saem um de cada vez)
B distribuição estatística do tempo de serviço M – Processo de Markov
número de servidores ou capacidade de
c 1, 2, ..., ∞6
atendimento
número máximo de pacotes permitidas no
K 1, 2, ..., ∞
sistema
m tamanho da população de pacotes 1, 2, ..., ∞
FIFO – o primeiro que chega é o primeiro a ser
Z Disciplina da fila
atendido
A notação M/M/1/10/∞/FIFO indica um processo com chegadas Marcovianas, atendimento

também Marcoviano, um servidor, capacidade máxima do sistema igual a 10 pacotes,
população infinita e o primeiro que chega é o primeiro a sair do sistema.
A notação M/M/1 é o Sistema de Fila mais simples, com chegadas e atendimento

Marcovianos, um servidor, capacidade do sistema infinita, população infinita e o primeiro que
chega é o primeiro a sair do sistema, é a abreviação de M/M/1/∞/∞/FIFO, ou seja:
M / M /1 ⇔ M / M /1/ ∞/∞/ FIFO
A disciplina de fila FIFO (primeiro que chega é o primeiro a sair do sistema) será a adotada
para os Sistemas Computacionais, por ser uma simplificação razoável.
Exemplo 2.1 Escalonamento FIFO (First in First out – Primeiro a Chegar – Primeiro a Sair)
O escalonamento FIFO (não-preemptivo7) é o de implementação mais simples. Desta forma, o primeiro pacote
que chega é o primeiro a ser enviado para o Servidor. Os pacotes são organizados em uma fila, que funciona
6 Os valores infinitos adotados para c, K e m são simplificações para evitar cálculos de probabilidade com reposição, simplificam os mode-
los sem afetar suas aplicações e suas interpretações – os resultados justificam tais aproximações.
7 No escalonamento não-preemptível um pacote não pode ser retirado do Servidor.
baseado na política FIFO. Considere o seguinte conjunto de pacotes:

Pacote na Fila Tempo de Serviço (ut)
p1 3
p2 6
p3 4
p4 5
Supondo que a ordem de chegada dos pacotes seja: p 1, p2, p3 e p4. Dessa forma, conforme a política FIFO, a
ordem de execução dos pacotes é mostrado diagrama de tempo abaixo.
Para este conjunto de pacotes o tempo de espera do pacote p 1 é de 0 (zero) unidades de tempo; para o pacote
p2 de 3 unidades de tempo; para o pacote p3 de 9 unidades de tempo; e para o pacote p 4 de 13 unidades de
tempo. O tempo médio de espera na fila é de (0+3+9+13)/4, que é igual a 6,25 unidades de tempo.
A disciplina de fila SJF(Shortest Job First – Menor Tarefa Primeiro), o pacote da Fila que tem o
menor tempo de serviço é encaminhado ao Servidor, Exemplo 2.2.
Exemplo 2.2 Escalonamento SJF – Shortest Job First (Menor Tarefa Primeiro)
Neste escalonamento, o pacote da Fila que tem o menor tempo de serviço é encaminhado ao Servidor.
Considere o seguinte conjunto de pacotes:
Pacote na Fila Tempo de Serviço (ut)
p1 3
p2 6
p3 4
p4 5
Supondo que a ordem de chegada dos pacotes seja: p 1, p2, p3 e p4, e que todos eles estão na Fila. Conforme a
política SJF, a ordem de execução dos pacotes é mostrado diagrama de tempo abaixo.
Neste escalonamento, o tempo de espera do pacote p 1 é de 0 unidade de tempo (ut); para o pacote p 3 é de 3
ut; para o pacote p4 é de 7 ut; e para o pacote p 2 é de 12 ut. O tempo médio de espera na Fila é de 5,5 ut,
(0+3+7+12)/4.
Segundo Silberschatz, trata-se de um escalonamento ótimo, em média, neste escalonamento, os pacotes
esperam menos para serem processados pelo Servidor.
2.1 Sistemas de Fila M/M/1
O modelo Fila+Servidor é o mais simples dos Sistemas de Fila, possui uma única Fila e
apenas um Servidor, a Figura 2.2 é o seu símbolo.
Figura 2.2 Representação gráfica de Sistemas de Fila simples destacando sua estrutura, os
processos de chegada e saída, a formação da Fila com pacotes em espera e o Servidor.
Este modelo é a unidade básica da simulação discreta, embora possua estrutura simples, ele
é bem estudado e tem sido bem-sucedido em representar o comportamento dos Sistemas
Computacionais. Este modelo pode ser associados em série e, ou, em paralelo para simular
Sistemas Computacionais, como circuitos integrados, componentes de hardware e software e
rede de computadores. Ele pode ser usado para analisar os recursos individuais de sistemas
de computação, por exemplo: se instruções a serem processadas por uma CPU são mantidas
em uma memória. A CPU pode ser modelada por um Sistema de Fila, onde a memória é a Fila
e a CPU é o Servidor do sistema.
Em Sistemas de Fila M/M/1, os pacotes chegam na Fila à taxa média λ, o processo de

chegada é Marcoviano, com distribuição de probabilidade exponencial. Os pacotes são
atendidos à taxa de serviço μ, o processo de atendimento é Marcoviano, com distribuição de
probabilidade exponencial.
Inicialmente, o Sistemas de Fila está ocioso, não há pacote na Fila e nem no Servidor. A Fila
está vazia e o Servidor ocioso. O primeiro pacote que chega no sistema passa pela Fila e vai
para o Servidor. A Fila continua vazia e o Servidor fica ocupado. À medida que chegam mais e
mais pacotes, em geral, há formação de Fila e o Servidor processa continuamente os pacotes
que chegam.
Vale destacar que os eventos discretos, chegar na Fila, entrar no Servidor e sair do Servidor,
serão de grande valia nos Modelos Conceitual e Computacional de Sistemas de Fila M/M/1.
Em Sistemas de Fila M/M/1, pode-se considerar dois tipos de grandezas para descrever seu
comportamento. A primeira é o número de pacotes na Fila e no Servidor. A segunda é o
tempo dos pacotes na Fila e no Servidor. Essas variáveis são aleatórias e são denominadas
variáveis fundamentais dos Sistemas de Fila M/M/1, e estão representadas na Figura 2.3 e
descritas na Tabela 2.4.
Na Figura 2.3 pode-se destacar cinco níveis relacionados às variáveis aleatórias

fundamentais dos Sistemas de Fila M/M/1, a saber:
1. no nível superior, tem-se os processos que ocorrem nestes sistemas, a chegada, a espera, o serviço
e a saída
2. no nível abaixo, destacam-se as taxas de chegada (λ) e de serviço (μ)
3. nível intermediário, estão os números do sistema, nq, ns e n, número de pacotes na Fila, no
Servidor e no Sistema de Fila, respectivamente, n = nq + ns
4. no próximo nível, estão os eventos discretos do sistema, a saber, chegar na Fila, entrar no Servidor
e sair do Servidor
5. no último nível estão os tempos do sistema, w, s e r, tempo de espera na Fila, tempo de
permanência no Servidor e tempo total no Sistema de Fila, respectivamente, sendo r = w + s. O
intervalo entre chegadas é a diferença entre os tempos de duas chegadas sucessivas.
Figura 2.3 Representação gráfica das variáveis aleatórias fundamentais dos Sistemas de Fila
M/M/1, adaptado de Jain (1991).
Exemplo 2.3 Representação gráfica das variáveis aleatórias temporais relacionadas aos eventos dos Sistemas
de Fila M/M/1
Em termos de simulação, a entrada sucessiva de pacotes

em um Sistema de Fila, como os pacotes P i-1 e Pi da figura
ao lado, e seus três eventos discretos (∎ - chegar na Fila, ∎
- entrar no Servidor e ∎ - sair do Servidor), permitem defi-
nir cinco variáveis aleatórias temporais relacionadas à di-
nâmica do sistema.
Considerando o mesmo pacote, temos os tempos dos

eventos:
∎ - chegada de pacote na Fila (cpf)
∎ - entrada de pacote do Servidor (eps)
∎ - saída de pacote do Servidor (sps)
Considerando dois pacotes sucessivos, temos os tempos

eventos:
∎ - intervalo entre chegadas na Fila (ic)
∎ - intervalo entre saídas do Servidor (is)
Em termos de modelagem matemática:

ri = spsi – cpfi
si = spsi – epsi
wi = epsi – cpfi
ici = spsi – spsi-1
isi = cpfi – cpfi-1
Estas variáveis temporais permitem calcular as estatísticas do sistema e seu estudo detalhado.
Tabela 2.4 Variáveis aleatórias fundamentais dos Sistemas de Fila Simples (Jain, 1991)
Variável Descrição
λ taxa média de chegada na Fila por unidade de tempo
μ taxa média de serviço por Servidor por unidade de tempo
n número de pacotes no Sistema de Fila, na Fila e no Servidor
nq número de pacotes esperando na Fila ou comprimento da Fila
ns número de pacotes no Servidor ou número de pacotes sendo atendidos
r tempo de resposta do sistema ou tempo no Sistema de Fila
w tempo de espera na Fila
s tempo de permanência no Servidor
Na Tabela 2.5 estão as Leis de Little, Equações 2.1, 2.2 e 2.3. Em termos práticos, estas leis
permitem converter valores de Tempo no Sistema em seus respectivos valores de Número no
Sistema.
Tabela 2.5 Estabilidade, Tempo e Número no Sistema de Fila e na Fila.
Condição de estabilidade
• λ < μ, λ e μ são variáveis aleatórias
Número no Sistema x Número na Fila
• n = nq + ns, onde n, nq e ns são variáveis aleatórias

• E[n] = E[nq] + E[ns], o número médio de pacotes no Sistema de Fila é igual à soma do número médio de
pacotes na Fila e o número médio de pacotes no Servidor
• se a taxa de serviço é independente do número de pacotes na Fila, tem-se que Cov(n q,ns) = 0 e V[n] =
V[nq] + V[ns]. A variância do número de pacotes no Sistema de Fila é igual à soma da variância do
número de pacotes na Fila e a variância do número de pacotes no servidor
Tempo no Sistema x Tempo na Fila
• r = w + s, o tempo de permanência no Sistema de Fila é igual à soma do tempo de espera na Fila e do

tempo de serviço, r, w e s são variáveis aleatórias
• E[r] = E[w] + E[s], o tempo médio no sistema é igual à soma do tempo médio de espera na Fila e do
tempo médio de serviço
• se a taxa de serviço é independente do número de serviços na Fila, tem-se que Cov(w,s) = 0 e V[r] =
V[w] + V[s], a variância do tempo de permanência no sistema é igual à soma das variâncias do tempo
de espera na Fila e do tempo de serviço
Número no Sistema x Tempo no Sistema
• se pacotes não são perdidos devido à capacidade do sistema, o número médio de pacotes em um
sistema está relacionado com seu tempo médio de resposta pela equação:
número médio de pacotes no Servidor = taxa de chegada × tempo médio de serviço

E[ns] = λ E[s] 2.1
• similarmente, o número médio de pacotes na Fila de um sistema está relacionado com seu tempo
médio de espera pela equação:
número médio de pacotes no Servidor = taxa de chegada × tempo médio na Fila

E[nq] = λ E[w] 2.2
• da mesma forma, o número médio de pacotes no Sistema de Fila está relacionado com seu tempo
médio no sistema pela Equação 2.3
número médio de pacotes no Sistema = taxa de chegada × tempo médio no Sistema

E[n] = λ E[r] 2.3
A Teoria de Filas, desenvolvido por A. K. Erlang em 1909, é utilizada para descrever

analiticamente Sistemas de Fila por meio de fórmulas matemáticas. Seu uso permite
determinar várias medidas da efetividade destes sistemas, com a finalidade de indicar seu
desempenho. Os resultados analíticos da Teoria das Filas aplicados em Sistemas de Fila M/M/1
serão mostrados na próxima seção.
Exemplo 2.4 Modelagem e Simulação em Ciência e Tecnologia

Modelagem e Simulação (M&S) são importantes na Ciência & Tecnologia & Inovação pois são capazes de
representar sistemas reais por meio de modelos matemáticos, permitem representar sua dinâmica por meio de
simulação, explorar o seu comportamento de uma forma articulada que muitas vezes não é possível, ou
envolve riscos no mundo real.
Relação entre Simulação e Método Científico na base da pesquisa.
A M&S usa diversas áreas de Ciência da Computação, bem como são influenciadas pela Teoria de Sistemas,
Engenharia de Sistemas e Engenharia de Software, dentre outras áreas do conhecimento. Esta base é tão
diversa quanto a da Gestão e da Engenharia, reunindo elementos de arte, engenharia e ciência de uma forma
complexa e única.
A M&S está calcada em modelos, que podem ser compostos de diferentes unidades vinculadas ao
cumprimento de um objetivo específico. Por isso M&S também pode ser chamadas de soluções de modelagem.
De modo mais geral, modelagem e simulação são metodologias chave para atividades de engenharia de
sistemas, pois a representação de sistema em um modelo legível por computador permite que os engenheiros
reproduzam o comportamento do sistema, uma maneira de apoiar as atividades de engenharia de sistemas
em seu processo de tomada de decisão.
Fonte: Adaptado de Modeling and simulation (en.wikipedia.org/wiki/Modeling_and_simulation).
2.2 Revisão
2.3 Questões
1) Caracterize e diferencie Sistemas de Fila, Fila e Servidor.

2) Qual a razão para se considerar a tamanho da fila infinita?

3) Qual a razão para se considerar a tamanho da população infinita?
4) Qual o significado do valor λ? E do seu inverso?
5) Qual o significado do valor μ? E do seu inverso?
6) Como medir o valor de λ e μ?
7) Qual a importância da condição de estabilidade (λ < μ)?
8) Qual utilidade operacional da “Lei de Little”?
9) Qual a importância do Sistema de Fila M/M/1?
10) Porque Cov(nq,ns) = Cov(w,s) = 0?
3 MODELO ANALÍTICO DE SISTEMAS DE FILA
Na Teoria das Filas, os pacotes entram e saem no sistema de modo aleatório. Diferentes
pacotes chegam de modo imprevisível, ao acaso. O sistema os processa, um a um,
demorando mais tempos com uns do que com outros. O tempo dedicado a cada pacotes
também é imprevisível, é um tempo aleatório. Toda vez entra ou sai pacote do sistema ele
muda de estado. Pode-se afirmar que o estado de sistema é sua quantidade de pacotes.
Estes processos aparecem em inúmeras aplicações, como Sistemas de Filas, redes de
comunicação de computadores e engenharia de desempenho. Nestas aplicações, os
processos estocásticos têm estados discretos.
Seja n o número de pacotes de um Sistema de Fila Simples (SF), n ≥ 0. Quando n = 0, o

sistema está vazio ou ocioso. Neste caso, a única mudança de estado possível é chegar um
pacote, ou seja, n = 1. Quando o sistema tem k pacotes, pode chegar um novo pacote, n =
k+1, ou pode sair um pacote, n = k-1.
Resumindo, um SF pacotes chegam, são processados e saem do sistema de um em um. Não

chegam mais de um, nem são processados mais de um por vez. Seu estado é o seu número
de pacotes, n. Seu estado pode aumentar para n+1 com a chegada de um pacote, ou mudar
para n-1 com a saída de um pacote. Estes processos de chegada/saída de pacotes são
denominados transições de estado.
Para representar os SFs, seus estados e suas transições, é usado o Modelo de Markov, uma
maneira de representar sistemas e processos estocásticos do mundo real que codificam
dependências e atingem um estado estacionário ao longo do tempo. Sistemas de Markov são
modelados como uma sequência de estados e, a medida que o tempo passa, o sistema que
se move entre os estados com uma probabilidade específica. Como os estados estão
conectados, eles formam uma cadeia, essa forma de modelar o mundo é chamada de Cadeia
de Markov.
Uma Cadeia de Markov é o tipo mais simples de Modelo de Markov, onde todos os estados
são observáveis e as probabilidades convergem ao longo do tempo. Com isso, pode-se
descreve o comportamento de um SF ao longo do tempo. Observe que a Cadeia de Markov
tem um único estado, o valor de n, a cada ponto do tempo pode-se ter transições para n+1
ou n-1. Diz-se que Cadeias de Markov tem memória de curto prazo, dela pode-se saber a
última transição (chegou ou partiu pacote) ou a próxima transição (chegará ou partirá
pacote). Com isso, a trajetória até o estado atual não afeta a próxima transição, a única coisa
que pode influenciar a próxima transição é o estado atual. Um outro fato observável é que,
pode-se chegar ao estado atual de muitas maneiras diferentes, sempre combinando
chegadas/partidas.
As Cadeias de Markov nos quais as transições são discretas e restritas aos estados vizinhos
são Processos Nascimento Morte. Eles são utilizados para modelar sistemas nos quais os
pacotes chegam uma de cada vez e não em lotes. Por exemplo, o número de pacotes em
uma Fila com um único Servidor e chegadas individuais (e não em lotes) pode ser
representada como um Processo Nascimento Morte. Uma chegada na Fila (nascimento) faz
com que o estado mude parar n+1 e uma partida da Fila (morte), faz com que o estado mude
para n-1.
No contexto dos SFs, as chegadas/partidas são probabilidades condicionais e são

denominadas probabilidades de transição. As probabilidades de transição descrevem a
transição entre estados na cadeia como uma probabilidade condicional.
Para entender como a rotina de chegadas/partidas de pacotes evolui ao longo do tempo, há

dois componentes a serem considerados:
• estado inicial (n = 0 e tempo = 0 por conveniência)

• número de pacotes a serem processados
• estado final (resultados e tomada de decisão)
Os estados futuros são condicionados pelo estado da cadeia antes de cada transição. Uma
característica das Cadeias de Markov regular é que, ao longo de um número grande o
suficiente de iterações, todas as probabilidades de transição convergirão para um valor e
permanecerão inalteradas. Isso significa que, após um número suficiente de iterações, a
probabilidade de terminar em qualquer estado da cadeia é a mesma, independentemente de
onde ela começou. Então, quando a cadeia atinge este ponto, podemos dizer que as
probabilidades de transição atingiram um estado estacionário. O intervalo de tempo em que
a cadeia atinge um estado estacionário depende das transições possíveis entre os estados e
de suas probabilidades.
Apenas Cadeias de Markov regulares convergem com o tempo, permitindo obter resultados e
tomar decisões a respeito dos sistemas por elas modelados. As demais, as Cadeias de
Markov que não convergem com o tempo, não são de interesse da Engenharia pois não
geram resultados aplicáveis.
Os Sistemas de Fila M/M/m podem ser modeladas através de Cadeias de Markov, e neste
caso, considera-se que os tempos entre chegadas e atendimento são independentes,
igualmente distribuídos (iid) e exponencialmente distribuídos.
3.1 Modelo de Sistemas de Fila M/M/1
O Sistema de Fila M/M/1 é o mais simples, constituído por uma Fila e um Servidor, em que os
pacotes chegam de acordo com uma Cadeia de Markov e o tempo para atendê-las é
distribuído exponencialmente, Figura 3.1. O modelo também assume capacidade infinita do
sistema, os pacotes são provenientes de uma população infinita e a disciplina da fila é FIFO.
A Figura 3.1 apresenta o diagrama de transição de estado de um Processo Nascimento Morte

em um Sistema de Fila M/M/1.
Figura 3.1 Diagrama de transição de estado de Processo Nascimento Morte.
Quando o sistema está no estado n, os novos processos chegam a taxa λ n-1 e partem com
taxa de serviço μn, n > 0. Assumindo que os intervalos entre chegadas e os tempos de
serviço são exponencialmente distribuídos, a probabilidade de estado estacionário de um
Processo Nascimento e Morte de estar no estado n é dada pelo Teorema 1.1.
Teorema 1.1 A probabilidade do estado estacionário p n de um processo nascimento morte
estar no estado n, n > 0, é dada pela Equação 3.1
λ λ λ ⋯λ λ
pn = p 0 μ0 μ1 μ2 ⋯μn−2 μn−1 3.1
1 2 3 n−1 n
em que p0 é a probabilidade da Fila estar vazia, n = 0.
3.2 Modelo Analítico de Sistemas de Fila M/M/1
A Fila de Sistemas de Fila M/M/1, em que os pacotes podem aumentar ou diminuir um pacote
de cada vez. Este sistema pode ser modelado pelo Processo Nascimento Morte com taxas
homogêneas de nascimento λ e de morte μ. O diagrama de estado das taxas de transição
deste caso é mostrado na Figura 3.2.
Figura 3.2 Diagrama de transição de estado de Sistemas de Fila M/M/1 destacando o tamanho
da Fila e os valores constantes das taxas de transição λ e μ.
O estado desta Fila é dado pelo seu número de pacotes n, teoricamente n ∈ [0,∞) pois a
capacidade do sistema é infinita. Para λi = λ e μi = μ, i ∈ [0,n), o Teorema 1.1 nos dá a
seguinte expressão para a probabilidade de n pacotes do sistema:
n
pn= p0 λn 3.2
μ
A quantidade λ/μ é chamada de intensidade de tráfego e é indicada pelo símbolo ρ. Assim,
λ
ρ= μ 3.3
n
pn = p 0 ρ 3.4
Uma vez que a soma de todas probabilidades deve ser igual a 1, tem-se a seguinte
expressão para a probabilidade de zero pacotes na Fila do sistema, cuja demonstração está
no Capítulo 16 :
p0 =1−ρ 3.5
Substituindo p0 em pn, obtém-se:

n
pn =(1−ρ)ρ 3.6
A Utilização do Servidor é dada pela probabilidade de se ter um ou mais pacotes no sistema:

U =1− p 0=ρ 3.7
Quando não há pacotes no sistema, o Servidor é dito ocioso; caso contrário, o Servidor está
ocupado. O intervalo de tempo entre dois sucessivos intervalos ociosos é chamado de
período ocupado.
Na Tabela 3.1 estão os resultados do Modelo Analítico da Teoria das Filas aplicados a
Sistemas de Fila M/M/1. Estas estatísticas são obtidas a partir das equações acima
(demonstração no Capítulo 16 ), seu uso permite determinar várias medidas da efetividade
destes sistemas, com a finalidade de indicar seu desempenho.
Tabela 3.1 Resultados do Modelo Analíticos de Sistemas de Fila M/M/1 segundo a Teoria das
Filas (Jain, 1991)
- Parâmetros λ, μ
- Intensidade de tráfego λ
ρ= μ
- Condição de estabilidade ρ< 1
1 Probabilidade de zero pacote no Sistema de Fila p0=(1−ρ)
2 Probabilidade de n pacotes no Sistema de Fila pn=(1−ρ)ρn , n∈ℕ
ρ
3 Número médio de pacotes no Sistema de Fila E[n]=
1−ρ
ρ
4 Variância do número médio de pacotes no Sistema de Fila V [ n]= 2
(1−ρ)
{
2
1−ρ ,n q=0
5 Probabilidade de nq pacotes na Fila P[nq ]= n +1
(1−ρ)ρ , nq >0 q
ρ2
6 Número médio de pacotes na Fila E[nq ]=
1−ρ
2 2
ρ (1+ρ−ρ )
7 Variância do número médio de pacotes na Fila V [nq ]=
(1−ρ)2
−μ(1−ρ)r
8 FDA do tempo de resposta F( r)=1−e
1
9 Tempo médio de resposta E[r ]=
μ (1−ρ)
1
10 Variância do tempo de resposta V [r ]= 2 2
μ (1−ρ)
100
11 Percentil q do tempo de resposta w q=E [r ]ln ( )
100−q
12 Percentil 90 do tempo de resposta w 90=2,3 E[r ]
13 FDA do tempo de espera F( w)=1−ρ e−μ (1−ρ)w
ρ
14 Tempo médio de espera E[w ]= =ρ E[r ]
μ (1−ρ)
(2−ρ)ρ
15 Variância do tempo de espera V [w]=
μ 2 (1−ρ)2
E[w ] 100 ρ
16 Percentil q do tempo de espera max {0, ρ ln ( )}
100−q
17 Percentil 90 do tempo de espera

E[w ]
max {0, ρ ln (10ρ)}
18 Probabilidade de n ou mais pacotes no Sistema de Fila ρn
1 2n−2 n−1 1
19 Probabilidade de executar n pacotes no período ocupado
(
n n−1
ρ −
(1+ρ))
2 n−1
1
20 Número médio de pacotes executadas no período
1−ρ
ρ(1+ρ)
21 Variância do número médio de pacotes executados no período
(1−ρ)3
1
22 Duração média do período
μ (1−ρ)
1 1
23 Variância da média do período − 2
μ (1−ρ) μ (1−ρ)2
2 3
Os resultados analíticos apresentados na Tabela 3.1 estão discutidos no Capítulo 16 .

O seguinte exemplo ilustra a aplicação destes resultados na modelagem de um gateway de

rede, extraído de Jain (1991).
Exemplo 3.1 Em um gateway de uma rede, medições mostraram que os pacotes chegavam a uma taxa média
de 125 pacotes por segundo (pps) e o gateway leva cerca de 2 milissegundos para transmiti-los. Usando um
modelo M/M/1, analise o gateway. Qual é a probabilidade de estouro de buffer se o tamanho do buffer do
gateway for igual a 13? Qual a tamanho do buffer para que a perda de pacotes seja menor do que um pacote
por milhão?
Taxa de chegada λ = 125 pps

Taxa de serviço µ = 1/0,002 = 500 pps
Intensidade do tráfego no gateway ρ = λ/μ = 0,25
Probabilidade de n pacotes no gateway = (1-ρ)ρn = 0,75(0,25)n
Número médio de pacotes no gateway = ρ/(1-ρ)= 0,25/0,75 = 0,33
Tempo médio gasto no gateway = (1/µ)/(1-ρ)= (1/500)/(1-0,25)=2,66 ms
Probabilidade de estouro de buffer = P(n > 13 pacotes no gateway) = ρ n = 0,2513= 1,49x10-8 ≈ 15 pacotes por
bilhões de pacotes
Para limitar a probabilidade de perda de pacotes para menos de 1x10 -6, ρn < 1x10-6 ou
n > ln(1x10-6)/ln(0,25) = 9,96.
Conclusão: o tamanho do buffer deve ser igual a 10.

Os dois últimos resultados sobre estouro de buffer são aproximados. Estritamente falando, o gateway deve ser
modelado como uma fila M/M/1/B, em que B é o tamanho do buffer. No entanto, uma vez que a utilização é
baixa e o tamanho do buffer está acima do comprimento médio da fila, estes resultados são boas
aproximações.
3.3 Revisão
3.4 Questões
1) O que são Cadeias de Markov?

2) Qual a importância dos Processos Nascimento Morte no Modelo Analítico de Sistemas de Fila M/M/1?
3) Qual a importância das taxas homogêneas de nascimento (λ) e de morte (μ) no Modelo Analítico de
Sistemas de Fila M/M/1?
4) Qual a utilidade das variáveis da Tabela 3.1 para o engenheiro?
5) Compare as Figura 3.1 e Figura 3.2.
6) De uma interpretação operacional para a Utilização do Servidor.
7) De uma interpretação operacional para “perda de pacotes menor do que um pacote por milhão”?
8) Dê um exemplo de modelo matemático usado para avaliar o desempenho acadêmico de graduandos.
Comente sobre suas deficiências? Porque são usados?
9) Como é calculado o preço do dólar americano em reais?
10) Como é calculada a inflação mensal da nossa moeda?
11) Qual a diferença entre uma opinião técnica e um modelo matemático?
12) Quando p0 tende a 0 como se comporta E[nq]?
13) Quando p0 tende a 1 como se comporta E[nq]?
14) Relacione este comentário com a temática deste capítulo: “Há muita matéria no universo – muita
mesmo. É uma quantidade difícil até mesmo de ser mensurada. No entanto, a matemática nos permite
fazer magia, e é completamente possível calcular a quantidade total de matéria no universo … [mas é
necessário ferramentas que possibilitam] comparações do mundo teórico com o mundo prático”.
Adaptado de Felipe Miranda, 2020 (socientifica.com.br/cientistas-medem-com-precisao-a-quantidade-
total-de-materia-no-universo).
3.5 Exercícios
1) Pacotes que chegam em um Sistema de Fila M/M/1 com intervalo entre chegadas λ = { 8, 5, 12, 15, 8,
11, 9, 10, 7, 6 } e tempos de serviço μ = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 10 }, calcule os resultados
analíticos deste sistema conforme a Tabela 3.1.
2) Compare os resultados analíticos do exercício 2 considerando os seguintes cenários:
a) aumento de λ em 10% e redução de μ em 10%

b) redução de λ em 10% aumento de μ em 10%
c) aumento de λ em 10% e aumento de μ em 10%
3) Repita o Exemplo 3.1 para pacotes que chegam a uma taxa média de 600 pps em um gateway que
processa um pacote em 1 milissegundo.
4) Qual a tamanho do buffer para que a perda de pacotes em um gateway (λ = 800 pps e µ = 700 pps) seja
menor do que um pacote por milhão?
4 MODELO CONCEITUAL DE SISTEMAS DE FILA
O modelos de Sistemas de Fila A/B/c/K/m/Z podem ser simulados por computador e, para
isso, é necessário desenvolver os modelos conceituais e computacionais destes sistemas.
Inicialmente, por uma questão de simplicidade, será desenvolvida uma metodologia para
realizar simulação de Sistemas de Fila M/M/1.
A Figura 4.1 ilustra a representação gráfica de Sistemas de Fila M/M/1 e seus elementos
constituintes: o Sistema de Fila (SF), uma Fila (F) e um Servidor (S). Os pacotes chegam na
Fila, um por vez, o Servidor os atendem também um por vez. Um pacote aguardará na Fila se
o Servidor estiver ocupado, caso contrário, será atendido. Uma vez atendido, o pacote deixa
o Sistema de Fila.
Figura 4.1 Modelo de Sistemas de Filas M/M/1 (SF) e seus elementos constituintes: a Fila (F), o
Servidor (S) e os pacotes aguardando processamento (retângulos cinzas).
A partir do Sistema de Fila M/M/1, pode-se derivar modelos dos demais Sistemas de Fila
M/M/c/K/m. Embora simples, os Sistemas de Fila M/M/1 fornecem informações úteis sobre o
desempenho de sistemas reais.
Primeiramente será apresentado e discutido o Modelo Conceitual dos Sistemas de Fila M/M/1
e, em seguida, o seu Modelo Computacional será apresentado e implementado em C++ e
Javascript. Por fim, será simulado e apresentado seus resultados na forma de tabela. A
dinâmica temporal dos resultados também será apresentada em HTML5, permitindo o
acompanhamento gráfico de suas variáveis de entrada, de estado, de saída e suas
estatísticas.
Conforme representadas na Figura 3.2 e descritas na Tabela 2.4 (capítulo anterior), as

variáveis aleatórias fundamentais dos Sistemas de Fila para sua modelagem são seus
eventos discretos: chegar na Fila, entrar no Servidor e sair do Servidor; e as estimativas dos
valores a eles associados: tempo entre chegadas e o tempo de serviço.
Os pacotes chegam nos Sistemas de Fila um por vez e são processadas em um Servidor
também um por vez. Os pacotes não chegam em lotes nem são processadas em lotes. Desta
forma, os Sistemas de Fila possuem as variáveis básicas:
Variável Descrição
τ tempo entre chegadas, isto é, o intervalo de tempo entre duas chegadas sucessivas
λ taxa média de chegada por unidade de tempo
s tempo de serviço, tempo requerido para processar pacotes ou tempo no Servidor
μ taxa média de serviço do Servidor por unidade de tempo
1. a relação entre a taxa de chegada (λ) e o intervalo entre chegadas (τ) é λ = 1/E[τ]8
2. a relação entre a taxa de serviço (μ) e o tempo de serviço (s) é μ = 1/E[s]
A Figura 4.2 ilustra o Modelo Conceitual de Sistemas de Fila M/M/1 adaptado de Jain (1991) e
nela pode-se destacar cinco níveis:
1. no nível superior, tem-se os processos que ocorrem nestes sistemas, a chegada, a espera, o serviço
e a saída
2. no nível abaixo, destacam-se as taxas de chegada (λ) e de serviço (μ)
3. nível intermediário, estão os números do sistema, nf, ns e nsf, número de pacotes na Fila (F), no
Servidor (S) e no Sistema de Fila (SF), respectivamente, sendo nsf = nf + ns
4. no próximo nível, estão os eventos discretos do sistema, a saber, tempo de chegada na Fila ( cpf),
início do serviço no Servidor (eps) e fim do serviço no Servidor (sps)
5. no último nível estão os tempos do sistema, tf, tps e tsf, tempo de espera na Fila, tempo de
permanência no Servidor e tempo total no Sistema de Fila, respectivamente, sendo tsf = tf + tps.
O intervalo entre chegadas é a diferença o tempo de chegada e o tempo da chegada anterior.
Figura 4.2 Modelo Conceitual de Sistemas de Fila M/M/1 com seus processos, variáveis de
entrada e saída, números e eventos em cinco níveis, adaptado de Jain (1991).
Os valores que ns pode assumir são 0 ou 1, correspondendo a Servidor livre ou Servidor

ocupado, respectivamente. Os valores que nf pode assumir são os inteiros positivos, nf ∈
[0,∞), temos também que nsf = nf + ns. As variáveis cpf, eps e sps, são as variáveis de
estado do sistema, são eventos discretos no tempo. Para o mesmo evento tem-se que sps ≥
eps ≥ cpf ≥ 0.
A Figura 4.2 é uma ilustração estática do Modelo Conceitual de Sistemas de Fila M/M/1. Mas
nela está implícito os aspectos dinâmicos deste modelo. Pacotes chegam continuamente no
8O símbolo E(x) é a esperança matemática ou valor esperado da variável aleatória x. Dada uma fdp f(x) ou p(x i), E(x) pode
+∞ n
ser calculada pelas equações E( X )= ∫ x f ( x )dx , X ∈ℝ e E(X )=∑ x i p (x i) , X ∈ℕ , respectivamente.
−∞ i=1
sistema, os pacotes um a um, são encaminhados para o Servidor e após, ser processadas,
saem do sistema. Este fluxo permite gerar uma tabela com os valores de cpf, eps e sps,
discutida abaixo9.
O Exemplo 4.1 ilustra uma aplicação do Modelo Conceitual de Sistemas de Fila M/M/1 com
suas entradas (ic = 1/λ e ts = 1/μ), os tempos de eventos (cpf, eps e sps) são suas
variáveis de estado e a dinâmica do sistema obtida a partir dos seus eventos (chegada, início
do serviço e fim do serviço). A partir dos valores destas variáveis é possível calcular os
indicadores do Sistema de Fila e avaliar seu comportamento.
Exemplo 4.1 Sejam N = 10 pacotes que chegam em um Sistema de Fila M/M/1 com intervalo entre chegadas ic
= { 8, 5, 12, 15, 8, 11, 9, 10, 7, 6 } e tempos de serviço ts = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 10 }, ic e ts em
segundos (s). A simulação do sistema é feita conforme mostrado na Tabela 4.1.
Tabela 4.1 Simulação de um Sistema de Fila M/M/1

p ic ts cpf eps sps
0 0 0
1 8 11 8 8 19
2 5 10 13 19 29
3 12 9 25 29 38
4 15 12 40 40 52
5 8 9 48 52 61
6 11 11 59 61 72
7 9 14 68 72 86
8 10 8 78 86 94
9 7 9 85 94 103
10 6 10 91 103 113
Os pacotes (p), seus intervalos entre chegadas (ic) e tempos de serviço (ts) são organizados segundo a ordem
de chegada a partir do tempo zero, p = 1, 2, ..., N. A Tabela 4.1 é preenchida calculando os valores das quatro
variáveis a seguir:
• cpf – tempo da chegada do pacote na Fila
• eps – tempo da chegada do pacote no Servidor, início do serviço
• sps – tempo da saída do pacote do Servidor, fim do serviço
Início da simulação: Fila vazia, Servidor ocioso e cronômetro zerado
• cpf0 = eps0 = sps0 = 0
Primeiro pacote:
• p=1
• ic1 = 8, ts1 = 11
• cpf1 = cpf0 + ic1 = 8, Fila vazia
• eps1 = tif1 = 8, Servidor ocioso
• sps1 = eps1 + ts1 = 19
Segundo pacote:
• p=2
• ic2 = 5, ts2 = 10
• cpf2 = cpf1 + ic2 = 13
• eps2 = 19, depois que p1 saiu do sistema, não antes
• sps2 = eps2 + ts2 = 29
Terceiro pacote:
• p=3
• ic3 = 12, ts3 = 9
• cpf3 = cpf2 + ic3 = 25
• eps3 = 29, depois que p2 saiu do sistema, não antes
9As variáveis aleatórias, intervalo médio entre chegadas sucessivas (ic) e o tempo médio para processar um pacote (ts), é
que são usadas no Modelo Conceitual de Sistema de Fila M/M/1. Seus valores são ic = 1/λ e ts = 1/μ. A unidade adotada
tanto para λ quanto para μ é pacote/segundo (p/s ou pps) – taxa temporal. A unidade tanto de ic quanto de ts é
segundo/pacote (s/p) – a frequência destes processos.
• sps3 = eps3 + ts3 = 38

Quarto pacote:
• p=4
• ic4 = 15, ts4 = 12
• cpf4 = cpf3 + ic4 = 40
• eps4 = 40, servidor ocioso
• sps4 = eps4 + ts4 = 38
E assim por diante.
4.1 Dados de Entrada para Simulação
Os dados de entrada para a simulação de Sistemas de Fila M/M/1 são a taxa média de
chegada ou os valores de ic de cada pacote e também a taxa média de serviço ou os valores
de ts de cada pacote. As unidades de ic e ts são segundo/pacote (s/p). Os valores de ic =
1/λ e ts = 1/μ.
O número de simulação (N) também é um dado de entrada. No Exemplo 4.1 foram simulados
10 pacotes. O valor adequado de N será estudado mais adiante.
O valor de ic depende do modelo de negócio. O tamanho do pacote, usado para calcular o

valor de ts, depende do serviço prestado, que depende também do modelo de negócio.
Dados medidos podem ser encontrados na web. O infográfico da Nasdaq de 2020 e 2021
apresentados na Figura 4.3, é o tráfego por minuto de plataformas e aplicativos mundiais
nestes anos. Com estes dados pode-se estimar o valor de ic destas plataformas e aplicativos,
como mostra o Exemplo 4.2.
(a) (b)
Figura 4.3 Tráfego em plataformas e aplicativos a cada minuto em: (a) 2020 e (b) 2021 (Domo 8, 2020; Domo 9,
2021).
Exemplo 4.2 Com os dados da Figura 4.3a, referente ao tráfego por minuto de plataformas e aplicativos
mundiais no ano de 2020, pode-se estimar o valor de ic destas plataformas e aplicativos, como ilustra a Tabela
4.2.
Tabela 4.2 Estimativas dos valores ic de alguns aplicativos obtidos a partir da Figura 4.3a
Plataforma Pacotes por Minuto λ (p/s) ic (s/p)
Amazon 6.659 111 0,00900
Facebook 150.000 2500 0,0004000
Zoom 208.333 3472 0,0002880
Instagram 347.222 5787 0,0001728
Exemplo 4.3 Estimar o tamanho máximo de um pacote do Instagram?
Comprimentos máximos de itens de uma mensagem do aplicativo Instagram, em caracteres, são destacados
abaixo10:
• legendas: 2.200 caracteres

• hashtags: 30 hashtags de até 24 caracteres
• biografia: 150 caracteres
• nome de usuário: 30 caracteres
Tamanho máximo de um pacote do Instagram = 2200 + 30 x 24 + 150 + 30 B = 3100 B ≈ 3 KB

Vale destacar que pacotes são partes dos protocolos de comunicação. Quando os pacotes são muito pequenos,
o tamanho dos protocolos de comunicação não precisa ser considerado.
Exemplo 4.4 Estimar o tamanho máximo de um pacote do Instagram em tráfego na Internet?
Incluindo, a título de exemplo, o pacote máximo do Instagram no protocolo IPv6, temos:

• datagrama do protocolo IPv6 = 320 b = 40 B
• pacote do Instagram = 3100 B
Tamanho do pacote em trafego IPv6 = 3140 B
O protocolo IPv6 representa 1,3% do tamanho do pacote final.
Exemplo 4.5 Estimar o tamanho máximo de um pacote do Twitter?
Comprimentos máximos de itens de uma mensagem do aplicativo Twitter, em caracteres, são destacados
abaixo (sem DM):11
• Tuíte: 140 caracteres

• Usuário: 15 caracteres
• Nome de perfil: 20 caracteres
Tamanho máximo de um pacote do Twitter = 140 + 15 + 20 B = 175 B

Observe que o datagrama do IPv6 (40 B) deve ser inserido no pacote do Twitter para fins de tráfego na
Internet, desta forma, o pacote final terá 215 B.
O protocolo IPv6 representa 18,6% do tamanho do pacote final, o que é considerável.
Exemplo 4.6 A memória RAM GDDR6X da Nvidia GeForce RTX 3080 tem taxa de transferência de 19 Gb/s. Qual
o tempo de serviço desta RAM para pacotes de 5 MB?
Tamanho do pacote = 5 MB
Taxa de serviço:
10 Fonte: https://sproutsocial.com/insights/contador-de-caracteres-nas-redes-sociais/#instagram
11 Fonte: https://sproutsocial.com/insights/contador-de-caracteres-nas-redes-sociais/#twitter
Gb pacote 19Gb pacote 19 Gb 19×1024 Mb

μ=19 Gb/s=19 = = pps= =486,4 pps
s pacote pacote s 5 MB 5 M ×8 b
1 1
Tempo de serviço: ts= μ = =0,00205 s / p
486,4 pps
Ou seja, esta memória pode transferir, aproximadamente, 486 pacotes de 5 MB a cada segundo; o tempo
requerido para transferir um único pacote de 5 MB é 0,00205 s.
Exemplo 4.7 Sabe-se que a HD Samsung 860 EVO de 1 TB, com 550 MB/s (leitura sequencial) e 520 MB/s
(escrita sequencial) está sendo usada para leitura e gravação de arquivos de tamanhos médio iguais a 2,5 MB.
Qual o tempo de serviço (ts) desta HD quando usada para leitura (ts leitura)? Qual o valor de tsgravação? Qual o
tempo de serviço médio desta HD?
Tamanho do pacote = 2,5 MB

Taxa de serviço (leitura):
pacote 550 MB pacote 550 MB pacote pacote
μleitura =550 MB /s=550 MB /s = = =220 =220 pps
pacote pacote s 2,5 MB s s
pacote pacote
Taxa de serviço (gravação): μ gravação =520 MB /s=520 MB / s =208 =208 pps
pacote s
μ leitura +μ gravação
Taxa de serviço média: μ= =214 pps
2
1 1
Tempo de serviço (leitura): tsleitura = μ = =0,00455 s/ p
leitura 220 pps
1 1
Tempo de serviço (gravação): ts gravação = μ = =0,00481 s/ p
gravação 208 pps
1 1
Tempo de serviço médio: ts= μ = =0,00467 s/ p
214 pps
Exemplo 4.8 A Nvidia GeForce RTX 3080 tem taxa bruta de 29,77 Teraflops (TFLOPS 12) de performance
computacional. Qual o tempo de serviço desta placa para multiplicação de matrizes quadradas de tamanho
5000?
O tempo de execução para a multiplicação de matrizes quadradas de ordem n é O(n³) – algoritmos

convencionais.
Tamanho do pacote = 5000³= 1,25e11 FLOP
Taxa de serviço:
12
29,77 TFLOP pacote 29,77 TFLOP 29,77 10 FLOP
μ=29,77 TFLOPS= = pps= pps=238,2 pps
s pacote pacote 1,25×1011 FLOP
1 1
238,2 pps
Ou seja, esta placa pode multiplicar, aproximadamente, 238 matrizes quadradas de ordem 5000 a cada
segundo, a duração de uma única multiplicação é 0,00420 s.
Exemplo 4.9 A Nvidia GeForce RTX 3080 tem taxa bruta de 29,77 Teraflops (TFLOPS) de performance
computacional. Qual o tempo de serviço desta placa para multiplicação de matrizes quadradas de tamanho
5000 utilizando o algoritmo de Strassen ≈ O(n2,807)?
O tempo de execução para a multiplicação de matrizes quadradas de ordem n é O(n³) – algoritmos

convencionais.
12 FLOPS - FLoating-point Operations per Second (operações de ponto flutuante por segundo), usado para determinar o
desempenho de um computador, especificamente no campo de cálculos científicos; similar a instruções por segundo.
Tamanho do pacote = 50002,807= 24,2e9 FLOP

Taxa de serviço:
29,77 TFLOP pacote 29,77 TFLOP 29,77 1012 FLOP

μ=29,77 TFLOPS= = pps= 9
pps=1230,2 pps
s pacote pacote 24,2×10 FLOP
1 1
1230,2 pps
Ou seja, o algoritmo de Strassen e esta placa podem multiplicar, aproximadamente, 1230 matrizes quadradas
de ordem 5000 a cada segundo, a duração de uma única multiplicação é 0,000813 s.
4.2 Valores Iniciais da Simulação
O estado inicial do Sistema de Fila é de Fila vazia e Servidor ocioso 13 (nf = ns = 0). Para
iniciar a contagem do tempo, o cronômetro é zerado (cpf = eps = sps = 0). No Exemplo 4.1,
após 8 s chega o primeiro pacote (p = 1, ic = 8 s/p, ts = 11 s/p), ele chega na Fila em cpf =
8 s. Como o Servidor está ocioso, ele recebe o pacote em eps = 8 s e demora 11 s para
processá-lo, assim sps = 8+11 = 19 s.
Generalizando, os seguintes comandos resumem os valores iniciais das variáveis do Sistemas

de Fila para p = 1:
1. eps[1] = cpf[1] = ic[1]

2. sps[1] = eps[1] + ts[1]
Para fins computacionais, uma maneira prática de tratar o primeiro pacote é fazer:
ic = ts = cpf = eps = sps = nf = ns = 0
4.3 Cálculo de cpf
Quando o segundo pacote chega na Fila do sistema no Exemplo 4.1 (p = 2, ic = 5 s, ts = 10

s/p), o tempo transcorrido é a soma dos ic dos pacotes anteriores, neste caso são 8+5 = 13
s/p. Esta soma é armazenada em cpf, logo cpf[2] = cpf[1] + ic[2] = 8 + 5 = 11 s/p.
Generalizando, cpf[p] = cpf[p-1] + ic[p], p ∈ [2,N].
4.4 Cálculo de eps
Quando o segundo pacote chega no Sistema de Fila no Exemplo 4.1, o Servidor pode estar
ocioso ou ocupado. Se ele estiver ocioso, ele recebe o pacote e o valor de eps é igual ao de
cpf, ambos do segundo pacote, Figura 4.4.a. Se ele estiver ocupado, esta situação perdurará
até o tempo sps do pacote anterior e, assim, eps é igual ao valor de sps do pacote anterior,
Figura 4.4.b.
13 O estado inicial do Sistema de Fila para o início da simulação (Fila vazia, Servidor ocioso, cronômetro zerado) é de ordem
prática e busca contornar as condições iniciais reais do sistema. Como consequência, a simulação apresenta grande
variabilidade nos resultados iniciais, denominado período transiente, no qual observa-se fortes flutuações nos valores
simulados com tendência de crescimento. Em seguida, o comportamento da simulação apresentam flutuações menores e
em torno de valores médios, é o denominado período estacionário.
Desta forma, para o cálculo de eps[p], p ∈ [2,N], é necessário considerar duas alternativas,
a saber:
1. cpf[p] > sps[p-1] então eps[p] = cpf[p], o Servidor está ocioso e o pacote é enviado a ele (Figura
4.4.a)
2. cpf[p] ≤ sps[p-1] então eps[p] = sps[p-1], o pacote aguarda na Fila e será enviado ao Servidor
assim que ele finalizar o pacote anterior (Figura 4.4.b)
(a) (b)
Figura 4.4 Pacote chegando em Sistemas de Fila: a) Servidor ocioso quando cpf[p] > sps[p-1]
e eps[p] = cpf[p]; b) Servidor ocupado quando cpf[p] ≤ sps[p-1] e eps[p] = sps[p-1].
Vale destacar que eps[p] ≥ cpf[p], ∀p ∈ [1,N].

Exemplo 4.10 Representação gráfica dos valores de eps relacionadas aos eventos e pacotes dos Sistemas de
Fila M/M/1
Na figura ao lado, estão representados três pacotes de um Sis-

tema de Fila, Pi-2, Pi-1 e Pi. Cada pacote com seus três tempos
dos eventos discretos: ∎ - chegada de pacote na Fila (cpf), ∎ -
entrada de pacote no Servidor (eps) e ∎ - saída de pacote do
Servidor (sps).
O valor de cpf de um pacote é calculado em função da taxa de

chegada, já sps deste mesmo pacote depende da taxa de ser-
viço e eps.
O valor de epsi depende do valor de spsi-1, ou seja, para calcu-

lar epsi de um pacote é necessário o valor de sps do pacote
que o antecede.
Ao chegar no Sistema de Fila, o pacote será encaminhado ao

Servidor se ele estiver ocioso. Servidor ocioso indica que o pa-
cote anterior foi processado e, neste caso, cpfi > spsi-1. Por
outro lado, se o Servidor estiver ocupado então o pacote
anterior ainda não foi processado e, neste caso, cpfi ≤ spsi-1.
Em termos matemáticos, o cálculo de eps de Pi-1 e Pi da figura acima é:
epsi-1 = spsi-2
epsi = cpfi
Em termos de modelagem matemática, o cálculo de eps de um pacote Pi qualquer é dado por:

se cpfi > spsi-1 então epsi = cpfi senão epsi = spsi-1, exceto o primeiro pacote para o qual eps0 = cpf0.
4.5 Cálculo de sps
Quando o segundo pacote sai do Servidor do Sistema de Fila no Exemplo 4.1 o tempo
transcorrido é igual ao valor de eps acrescido de ts, ambos do segundo pacote.
Generalizando, sps[p] = eps[p] + ts[p], p ∈ [1,N].

4.6 Estatísticas do Modelo Conceitual de Sistemas de Fila
As variáveis aleatórias dos Sistemas de Fila M/M/1, suas equações ou seus valores esperados
estão listadas nas Tabela 4.3, adaptado de Chung (2004). Estas equações podem ser
adaptadas para Sistemas de Filas A/B/c/K/m/Z.
Tabela 4.3 Valores das variáveis aleatórias dos Sistemas de Fila M/M/1 e seus valores médios,
para p ∈ [1,N].
VA Descrição Estatística Equação
T tempo da simulação T =sps[ N ] 4.1
tf[p] tempo de espera do pacote p na Fila t f [ p]=eps [ p]−cpf [ p] 4.2
ts[p] tempo de processamento do pacote p no Servidor t s [ p ]=sps [ p]−eps [ p ] 4.3
tsf[p] tempo de processamento do pacote p no Sistema de Fila t sf [ p ]=sps[ p]−cpf [ p] 4.4
1
E(nf) número médio de pacotes na Fila E(n f )=
N
∑ n f [ p] 4.5
1
E(ns) número médio de pacotes no Servidor E(n s)=
N
∑ ns [ p] 4.6
1
E(nsf) número médio de pacotes no Sistema de Fila E(n sf )=
N
∑ n sf [ p] 4.7
1
E(tf) tempo médio de espera de pacotes na Fila E(t f )=
N
∑ tf [ p ] 4.8
1
E(ts) tempo médio de processamento de pacotes no Servidor E(t s )=
N
∑ t s [ p] 4.9
1
E(tsf) tempo médio de processamento de pacotes no Sistema de Fila E(t sf )=
N
∑ t sf [ p] 4.10
1
U utilização do Servidor U=
T
∑ ts[ p ] 4.11
p0 probabilidade de Servidor ocioso p0=1−U 4.12
Tempo da Simulação ou Duração da Simulação (T) é igual ao valor do último evento da

simulação, que é de sps, Equação 4.1. Este valor corresponde ao intervalo de tempo
compreendido entre o início da simulação (cpf[0] = 0) e o seu final, o tempo que o último
pacote sai do sistema, sps[N].
Os pacotes no Sistema de Fila incluem as que estiverem na Fila e também a que estiver no
Servidor. Os pacotes na Fila excluem o que estiver no Servidor. Os pacotes no Servidor
excluem os que estiverem na Fila.
A simulação processa tempos e eventos, não são medidas operacionais, são etapas
intermediárias para estimar tf, tps, nf, ns e U, estatísticas úteis de Sistemas de Fila que
permitem sua avaliação técnica e suas aplicações em engenharia.
4.7 Algoritmo para Calcular nf
Para calcular o valor de nf é necessário comparar os valores de cpf de um dado pacote com
os de sps dos pacotes anteriores. Considerando o Servidor inicialmente ocioso, tem-se:
• o pacote p = 1, o primeiro a chegar no Sistema de Fila e vai para o Servidor, isto é nf[1] = 0
• quando o segundo pacote (p = 2) chegar no Sistema de Fila, o Servidor pode estar ocioso ou ocupado.
Se o Servidor estiver ocioso, não há pacote na Fila, então cpf[2] ≥ sps[1] e nf[2] = 0. Se o Servidor
estiver ocupado então cpf[2] < sps[1] e nf[2] = 1
• o terceiro pacote (p = 3), ao chegar no Sistema de Fila, se cpf[3] ≥ sps[2] então o Servidor está ocioso e
nf[3] = 0, caso contrário nf[3] = 1, pelo menos o pacote 2 está na Fila. Se cpf[3] < sps[1] então o
primeiro pacote ainda está na Fila e nf[3] = 2.
Generalizando, quando o p-ésimo pacote chega no Sistema de Fila, o tamanho da Fila n f[p]
será igual à contagem dos casos em que cpf[p] < sps[c], c ∈ [1,p-1], Equação 4.13 e Figura
4.5.
p−1
n f [ p ]=∑ 1 , cpf [ p ]<sps [c ] 4.13
c=1
A Figura 4.5 mostra 5 pacotes na reta do tempo na qual são destacados seus valores de cpf,
eps e sps. Ao sair do Sistema de Fila, o pacote p-4 dá lugar ao processamento do pacote p-3
e, sequencialmente, chegam os pacotes p-2, p-1 e p. Como o valor de cpf[p] é menor do
que sps[p-1], sps[p-2] e sps[p-3], o valor de nf[p] é igual a 3.
Figura 4.5 Valor de cpf do pacote p em relação aos valores de sps dos pacotes anteriores,
indicando 3 pacotes na Fila, ou seja, cpf[p] > sps[p-4].
Exemplo 4.11 Representação gráfica dos valores de n f relacionadas aos eventos e pacotes dos Sistemas de Fila
M/M/1
Na figura acima estão representados seis pacotes de um Sistema de Fila, P i-5, Pi-4, Pi-3, Pi-2, Pi-1 e Pi. Cada pacote
com seus três tempos dos eventos discretos: ∎ - tempo de chegada na Fila (cpf), ∎ - tempo de início de serviço
(eps) e ∎ - tempo de fim de serviço (sps).
Um pacote, ao chegar no Sistema de Fila, pode ir para o Servidor ou esperar na Fila. Ele espera sempre que
cpfi ≤ spsi-1. Pode ter mais de um pacote na Fila e, para contá-los é necessário comparar os valores de cpf
com os valores de eps de todos os pacotes que o antecederam. A começar pelo seu antecessor.
Na figura acima, cpfi é menor do que epsi-1, epsi-2, epsi-3 e epsi-4, logo nf = 5, ou seja, quando o Pacote P i entra
na Fila ele encontra outros 5 esperando para serem atendidos.
A função void Nf( int ), Algoritmo 4.1, implementa a Equação 4.13 para calcular nf dos
pacotes simulados.
Algoritmo 4.1 Código em C++ para calcular nf de Sistemas de Fila M/M/1: a) usando o
comando for e b) usando o comando while (mais eficiente).
void Nf( int p ){ void Nf( int p ){
nf[p] = 0; int c = p-1;
for( int c = 0; c < p-1; c++ ) nf[p] = 0;
if( cpf[p] < sps[c] ) nf[p] += 1; while( cpf[p] < sps[c] ){
} nf[p] += 1;
c--;
}
}
(a) (b)
4.8 Algoritmo para Calcular U
A Utilização é a razão entre o tempo de ocupação do Servidor e o tempo da simulação,

Equação 4.14.
tempo de ocupaçãp do Servidor
U= 4.14
tempo da simulação
O tempo que o Servidor fica ocupado durante a simulação igual a soma dos valores de ts
durante todo processo e U pode ser estimada pela Equação 4.15. E p0 pode ser estimado a
partir de U, Equação 4.16.
∑ t s [ p] 1
N
4.15
U=
p=1
T
=
T
∑ t s[ p ]
p=1
p0 =1−U 4.16
O algoritmo Algoritmo 4.2 implementa a Equação 4.15 para calcular U e depois calcular p0.
Algoritmo 4.2 Código em C++ para calcular U e p0 de Sistemas de Fila M/M/1

T = sps[N-1];
Sx = 0;
for( int p = 0; p < N; p++ )
Sx += sps[p]-eps[p];
U = Sx/T;
p0 = 1-U;
4.9 Sumário do Modelo Conceitual de Sistemas de Filas
As Tabela 4.4, Tabela 4.5 e Tabela 4.6 resumem o Modelo Conceitual dos Sistemas de Fila
M/M/1.
Tabela 4.4 Modelo Conceitual de Sistemas de Fila M/M/1

Símbolo Descrição Valores
A Distribuição de tempo entre chegadas M – Processo de Poisson (Markoviano)
B Distribuição de tempo de serviço M – Processo de Poisson (Markoviano)
c Número de canais de serviços 1
K Capacidade do sistema ∞
m Tamanho da população ∞
Z Disciplina da fila FIFO – primeiro que chega é o primeiro a ser atendido
Tabela 4.5 Entrada, parâmetros, eventos e saída do Modelo Computacional de Sistemas de

Fila M/M/1
Entrada N, λ e μ
Parâmetros ic e ts, com ic = 1/λ e ts = 1/μ
Eventos cpf, eps, sps
Saída T, U, E[nf], E[tf], E[tsf], DP[nf], DP[tf], DP[tsf]
em que E é a esperança matemática (média aritmética) e DP é o desvio padrão14.
Tabela 4.6 Entrada, parâmetros, variáveis de estado e saída do Modelo Computacional de

Sistemas de Fila M/M/1
eps[1] = cpf[1] = ic[1]
p=1
sps[1] = cpf[1] +ts[1]
cpf[p] = cpf[p-1] + ic[p]
2≤p≤N cpf[p] > sps[p-1] então eps[p] = cpf[p] senão eps[p] = sps[p-1]
sps[p] = eps[p] + ts[p]
Exemplo 4.12 No Sistema de Fila M/M/1 simulado abaixo, com N = 10 pacotes, ic(s/p) = {3, 5, 4, 3, 8, 5, 9, 8,
7, 6 } e ts(s/p) = { 12, 12, 10, 9, 2, 2, 1, 3, 2, 5 }:
p ic ts cpf eps sps nf tf tsf

1 3 12 3 3 15 0 0 12
2 5 12 8 15 27 1 7 19
3 4 10 12 27 37 2 15 25
14O desvio padrão da variável aleatória x é dada por DP( x)= √( E(x 2)−[E (x)]2 ) .
4 3 9 15 37 46 2 22 31
5 8 2 23 46 48 3 23 25
6 5 2 28 48 50 3 20 22
7 9 1 37 50 51 3 13 14
8 8 3 45 51 54 4 6 9
9 7 2 52 54 56 1 2 4
10 6 5 58 58 63 0 0 5
∑ 58 58 19 108 166
Tem-se que T = sps[10] = 63 s.

Será calculado o valor de nf[8] a título de exemplo, neste caso nf[8] = 4:
• o pacote 8 chegou na Fila no tempo cpf[8] = 45 s e entrará no Servidor no tempo sps[7] = 51 s, ou

seja, no tempo 51 s ela está na Fila pois cpf[8] < sps[7]
seja, no tempo 15 s ela não está na Fila pois cpf[7] > sps[3]
• os pacotes anteriores já foram processados em sps[7] = 51 s.
Os outros valores de nf são calculados da mesma forma.

O tempo de espera na Fila é dada por tf[p] = eps[p]-cpf[p]. Os valores de tf estão calculados na tabela
acima, logo E[tf] = ∑tf[p]/N = 108/10 = 10,8 s.
O tamanho médio da Fila é E[nf] = ∑nf[p]/N = 19/10 = 1,9 ou E[nf] = 2
A utilização U = ∑ts[p]/T = 58/63 = 0,921 ou U = 92,1%.
O cálculo de p0 = 1-U = 0,079 ou p0 = 7,9%.
O cálculo de E[ts] = ∑ts[p]/N = 58/10 = 5,8 s.
O tempo médio no sistema E[tsf] = ∑(sps[p]-cpf[p])/N = 166/10 = 16,6 s.
4.10 Revisão
Parâmetros de entrada dos SF M/M/1: N, λ e μ
Valores iniciais (p = 0) e valores dos eventos dos sucessivos pacotes (0 < p < N):
Pacote SF
ic0 = X(λ)
ts0 = X(μ)
0 cpf0 = ic0
eps0 = cpf0
sps0 = eps0 + ts0
icp = X(λ)
tsp = X(μ)
p cpfp = icp + cpfp-1
epsp = cpfp > spsp-1 ? cpfp : spsp-1
spsp = epsp + tsp
Simulação:
for( int p = 0; p < N; p++ ){

Empacota(p);
}
Com:
p−1
n f [ p ]=∑ 1 , cpf [ p ]<sps [c ] ,
c=0
N−1
1
U = ∑ {sps [ p ]−eps[ p ]} e
T p=0
T =sps [ N−1] .
Estatísticas:
N−1
1
∑ {eps [ p]−cpf [ p]} DP [tf ]=√( E(tf )−[ E(tf )] ) ,
2 2
E[tf ]= e
N p=0
N −1
1
∑ {sps [ p]−cpf [ p]} DP [tsf ]=√( E(tsf )−[ E(tsf )] ) ,
2 2
E[tsf ]= e
N p=0
N −1
1
∑ nf [ p ] DP [nf ]= √( E (nf )−[ E(nf )] ) .
2 2
E[ nf ]= e
N p=0
Figura 4.6 Hierarquia dos conceitos relacionados ao Modelos da Simulação Discreta.
4.11 Questões
1. Quais as diferenças entre os modelos de Sistemas de Fila M/M/1 e M/M/5.

2. Como um sistema CPU+Memória pode ser simulado pelo Sistemas de Fila M/M/1 se a memória não tem
tamanho infinito?
3. Como pode-se estimar a performance de um computador em FLOPS?
4. Qual a implicação de Cov(nq,ns) = Cov(w,s) = 0 no Modelo Conceitual de SF?
4.12 Exercícios
1. Sabe-se que a HD Samsung 970 EVO de 1 TB, com 3.500 MB/s (leitura sequencial) e 2.500 MB/s (escrita
sequencial) está sendo usada para leitura e gravação de arquivos de tamanhos médio iguais a 5 MB.
Qual o tempo de serviço (ts) desta HD quando usada para leitura (tsleitura)? Qual o valor de tsgravação?
2. No Exemplo 4.8, o tempo de serviço para multiplicação de matrizes quadradas com a Nvidia GeForce
RTX 3080 foi de 0,00420 s/p, para matrizes de ordem 5000 e algoritmos convencionais com O(n³). Qual
é o ganho se usar o algoritmo de Strassen ≈ O(n2,807)?
3. Em abril de 2020, um projeto de computação alcançou 2,3 Eflop/s, combinando PlayStation 3, CPU e
GPU. Qual o tempo de serviço deste projeto para multiplicação de matrizes quadradas de ordem 5000?
4. Considere a figura abaixo e calcule: a) o valor de n f do pacote 8; b) situe a coluna eps no pacote 10; e c)
o tempo total da simulação até o pacote 12.
5 MODELO COMPUTACIONAL DE SISTEMAS DE FILA
O Modelo Computacional de Sistemas de Fila M/M/1 está representado pela classe clSF da
Tabela 5.1 e pelo Algoritmo 5.1 escrito em C++. Esta classe encapsula os dados de estrada
nos vetores ic e ts, as variáveis de estado nos vetores cpf, eps e sps, e o parâmetro N, para
o número de simulações a realizar.
Tabela 5.1 Classe clSF do Modelo Computacional dos Sistemas de Fila M/M/1.
clSF
N, ic[N], ts[N], cpf[N], eps[N], sps[N]
clSF( int N, vector<double> l, vector<double> m )
void Empacotar( int )
void Simular( void )
A classe clSF possui o parâmetro N, os dados de entrada ic e ts, e as variáveis de estado
cpf, eps e sps, o construtor clSF e os métodos Empacotar e Simular, conforme a Tabela
5.1. Estas variáveis, exceto N, são vetores de tamanho N.
Na função main são declaradas e atribuídos os valores de N, l e m. O construtor clSF

recebe, como parâmetros, a variável N e os vetores l e m; configura os vetores ic, ts, cpf,
eps e sps, e calcular os valores de ic e ts a partir de l e m, respectivamente. Em seguida
executa o método Simular que atribui os valores de cpf, eps e sps do primeiro pacote e,
por fim, executa o método Empacotar para p = 1, 2, 3, …, N-1, calculando os valores de cpf,
eps e sps de cada pacote, evento a evento.
Algoritmo 5.1 Código básico em C++ para simulação de Sistemas de Fila M/M/115
//------------------------------------------------------------------------------
#include <vector>
//------------------------------------------------------------------------------
using namespace std;
//------------------------------------------------------------------------------
class clSF{
private:
int N;
vector<double> ic, ts, cpf, eps, sps;
public:
clSF ( int, vector<double>, vector<double> );
void Empacotar( int );
void Simular ( void );
};
clSF::clSF( int N, vector<double> l, vector<double> m ){
this->N = N;
ic .resize(N);
ts .resize(N);
cpf.resize(N);
eps.resize(N);
sps.resize(N);
for( int i = 0; i < N; i++ ){
15 No Modelo Conceitual de Sistemas de Fila p ∊ [1,N] e no correspondente Modelo Computacional p ∊ [0,N-1], isto se deve
ao uso das características da linguagem C++.
ic[i] = 1/l[i];
ts[i] = 1/m[i];
}
}
void clSF::Empacotar( int p ){
cpf[p] = ic [p] + cpf[p-1];
eps[p] = cpf[p] > sps[p-1] ? cpf[p] : sps[p-1];
sps[p] = eps[p] + ts [p];
}
void clSF::Simular( void ){
cpf[0] = ic [0];
eps[0] = cpf[0];
sps[0] = eps[0] + ts[0];
for( int p = 1; p < N; p++ )
Empacotar(p);
}
int main( void ){
int N = 10;
vector<double> l = { 8, 5, 12, 15, 8, 11, 9, 10, 7, 6 },
m = { 11, 10, 9, 12, 9, 11, 14, 8, 9, 10 };
clSF SF(N,l,m);
SF.Simular();
return 0;
}
5.1 Técnica para Gerar ic e ts
Até agora foram utilizando os valores medidos de ic e de ts diretamente nos modelos mas,
para simular um número de pacotes maior do que o número de dados observados, é
necessário gerar variáveis aleatórias:
• ic a partir de λ, ic = 1/λ16
• ts a partir de μ, ts = 1/μ17
A geração de variáveis é feita a partir dos valores médios de dados medidos ou estimados.
Para isso será usada uma função distribuição de probabilidade exponencial para gerar
variáveis aleatórias a partir dos valores médios 18. As técnicas para gerar variáveis aleatórias
(GVA) a partir de geradores de números aleatórios (GNA) serão estudadas nos próximos
capítulos.
A função double X(double p) do Algoritmo 5.2 gera variáveis aleatórias da função distribuição
de probabilidade exponencial. Ela requer o parâmetro p (valor médio dos dados observados
ou estimados), neste caso p assume os valores de ic ou de ts. Quando p assume o valor de
ic, a função X gera variáveis aleatórias para intervalo entre chegadas. Quando p assume o
valor de ts, a função X gera variáveis aleatórias para tempo de serviço.
Algoritmo 5.2 Função C++ para gerar variáveis aleatórias com distribuição de probabilidade
exponencial
double X( double p ){
double u = (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
return -log(u)/p;
}
Os termos srand(), rand(), RAND_MAX fazem parte da biblioteca de números aleatórios das
linguagens C e C++ e serão estudados nos próximos capítulos.
Os valores ic e ts gerados pela função X variam para cada simulação realizada pois são
obtidas a partir de u, que é gerado aleatoriamente. Desta forma são gerados valores de ic e
de ts em torno de cada média fornecida.
16 Note que a unidade de medida de λ é p/s (pacote/segundo) e a unidade de medida de ic é s/p (segundo/pacote).
17 Note que a unidade de medida de μ é p/s e a unidade de medida de ts é s/p.
18 Pode-se usar qualquer função distribuição de probabilidade para gerar variáveis aleatórias, o uso da fdp exponencial está em
conformidade com os resultados do Modelo Analítico da Teria de Filas (M/M/1).
Podem ser usadas outras funções além da exponencial, basta incluir a função de interesse,
que será estudado mais adiante.
No Modelo Computacional temos ainda que:
• λ é o número de pacotes que chegam na Fila por unidade de tempo – taxa de chegada - dado medido ou
estimado
• μ é o número de pacotes processadas pelo Servidor por unidade de tempo – taxa de serviço - dado
medido ou estimado
• ic é o intervalo médio entre chegadas de pacotes na Fila
• ts é o tempo médio de serviço de pacotes do Servidor
• l é usado em lugar de λ, sendo ic = 1/l
• m é usado em lugar de μ, sendo ts = 1/m
5.2 Software SF.MM1.cpp
O código completo em C++ para simulação de Sistemas de Fila M/M/1, denominado

SF.MM1.cpp, pode ser visto no Algoritmo 15.1 do Capítulo 15.2.
O algoritmo SF.MM1.cpp tem mudanças na sua estrutura e organização interna quando

comparado com o do Algoritmo 5.2, a saber:
• os valores de l e m são valores médios, não são vetores

• os dados de entrada são N, l e m
• ic e ts são calculados a partir de l e m, respectivamente, utilizando a função X
• o vetor E para os valores médios de nf, ic, ts, cpf, eps, sps, tf, tps e tsf
• o vetor DP para os valores do desvio padrão nf, ic, ts, cpf, eps, sps, tf, tps e tsf
• as variáveis T, U e p0
No algoritmo SF.MM1.cpp, as variáveis de estado são calculados pelos métodos X, Iniciar,

Empacotar, Simular e Nf. Os indicadores são calculados pelo método Estatistica. O
relatório final é feito pelos métodos Tabela, Resumo e Legenda. Estes métodos são
descritos abaixo:
• X calcula variáveis aleatórias ic e ts utilizando a fdp exponencial

• Iniciar atribui valores para ic, ts, cpf, eps, sps e nf do primeiro pacote
• Empacotar calcula os valores de ic, ts, cpf, eps e sps dos demais pacotes
• Simular simula cada pacote, do segundo ao último, sequencialmente
• Nf calcula a variável de estado nf de cada pacote
• Estatistica calcula as médias e desvio padrão de nf, ic, ts, cpf, eps, sps, tf, tps e tsf
• Tabela relata os valores de ic, ts, cpf, eps, sps e nf de cada pacote no formato html
• Resumo calcula os valores de T, U e faz um resumo das médias e desvios padrões no formato html
• Legenda cria legenda no formato html
As variáveis utilizadas no software SF.MM1.cpp estão sumarizadas na Tabela 5.2.
Tabela 5.2 Variáveis utilizadas no software SF.MM1.cpp

Nome Descrição
Dados de Entrada
N número de pacotes da simulação
l taxa de chegada na Fila (p/s)
m taxa de serviço do Servidor (p/s)
Eventos
cpf tempo de chegada de pacote na Fila (s)
eps tempo de chegada de pacote no Servidor (s)
sps tempo de saída de pacote do Servidor (s)
Estatísticas
nf número de pacotes da Fila
tf tempo de espera na Fila (s)
ts tempo de permanência no Servidor (s)
tsf tempo de permanência no Sistema de Fila (s)
T duração da simulação (s)
U utilização do Servidor
Indicadores
E[X] E[nf], E[tf], E[ts], E[tsf]
DP[X] DP[nf], DP[tf], DP[ts], DP[tsf]
Exemplo 5.1 Foi executado o Algoritmo 15.1, com entradas N = 10, l = 6 p/s e m = 5,2 p/s, com os resultados
apresentados abaixo:
p ic ts cpf eps sps

0 0,16 0,76 0,16 0,16 0,92
1 0,10 0,10 0,26 0,92 1,02
2 0,12 0,04 0,38 1,02 1,06
3 0,02 0,05 0,40 1,06 1,11
4 0,40 0,03 0,80 1,11 1,14
5 0,01 0,06 0,80 1,14 1,21
6 0,76 0,23 1,56 1,56 1,79
7 0,07 0,02 1,63 1,79 1,81
8 0,03 0,07 1,66 1,81 1,88
9 0,02 0,11 1,68 1,88 1,99
Resumo
N 10
T 1,991
E[ic] 0,168
DP[ic] 0,057
E[ts] 0,148
DP[ts] 0,050
E[nf] 2,100
DP[nf] 2,767
E[tf] 0,313
DP[tf] 0,067
E[tsf] 0,461
DP[tsf] 0,058
U 0,743
Valores de ic gerados
A execução de ic = X(l) = 0,167 s/p) gera os N = 10 valores de ic a partir de X(l) conforme listados na tabela
acima. A figura abaixo é o gráfico de ic versus p. A linha ic (em cor preta) é constante e as colunas de ic (em
cor verde) varia ora acima ora abaixo do valor de λ, o que denota a aleatoriedade da simulação.
Valores de ts gerados
A execução de ts = X(m) = 0,191 s/p ) gera os N = 10 valores de ts a partir de X(m) conforme listados na
tabela acima. O gráfico de ts versus p estão no gráfico abaixo. A linha ts (em cor preta) é constante e a coluna
de ts (em cor laranja) varia em torno de μ e denota a aleatoriedade da simulação.
Os valores de ic e ts das figuras acima variam para cada simulação que for realizada pois são obtidas a partir
de u, que é gerado aleatoriamente. Desta forma são gerados valores de ic e de ts em torno da média p
fornecida.
Valores de cpf, eps e sps simulados

Os valores de cpf (verde), eps (laranja) e sps (azul) versus p estão no gráfico abaixo. Quando a coluna de cpf
tem o mesmo valor que a de eps significa que o pacote não esperou na Fila, chegou e foi direto para o
Servidor. Quanto maior a diferença entre cpf e eps maior será o tempo de espera na Fila. Quanto maior a
diferença entre as colunas sps e eps maior será o tempo de serviço.
Valores de tf, ts e tsf simulados

Os valores de tf (verde), ts (laranja) e tsf (azul) versus p estão no gráfico abaixo. O pacote p = 0 tem tf = 0
porque não espera na Fila, ao chegar, vai direto para o Servidor. O pacote e = 6 também não espera na Fila.
Quanto maiores os valores das colunas maiores serão a duração dos eventos.
Valores de nf simulados
Os valores de nf (cinza) versus p está no gráfico abaixo. Para p = 0 e p = 6 não tem pacote na Fila. Quanto
maior o valor das colunas, maior será o tamanho da Fila.
Exemplo 5.2 Utilize o SF.MM1.cpp (Algoritmo 15.1), para avaliar a capacidade do servidor HPE ProLiant ML110
E5-2640v4, com vazão de 8,0 GT/s19, em processar as mensagens do Instagram.
No Exemplo 4.4 foi estimado o tamanho do pacote do Instagram como sendo 3100 B e na Tabela 4.2 está sua
demanda que é λ = 5787 p/s.
Tamanho do pacote = 3100 B
Taxa de serviço:
3
GB pacote 8GB pacote 8 GB 8×1024 B 6
μ=8 GT / s=8 = = pps= =2770946 pps=2,8×10 pps
s pacote pacote s 3100 B 3100 B
Configuração do SF.MM1.cpp: N = 5000, l = 5787.0, m = 2770946.0
Resultados obtidos:
l = 5787
m = 2770946
N = 5000
T = 0,876
E(ic ) = 0,000175
E(tf) = 0,0000000012
E(ts) = 0,000000359
E(tsf) = 0,000000361
E(nf ) = 0
DP(ic) = 0,0001743472
DP(tf) = 0,0000000322
DP(ts) = 0,0000003632
DP(tsf) = 0,0000003648
DP(nf ) = 0,0489309718
U = 0,0020491593
Conclusão: a simulação resultou em U ≈ 0 e valores médios de tsf ≈ 0 e de nf = 0; sendo assim, o servidor

HPE ProLiant ML110 E5-2640v4 é recomendado para o processamento de mensagens do Instagram, embora
apresente grande ociosidade.
Recomendação: se este projeto for implantado, recomenda-se fortemente monitorar e avaliar a solução
proposta para julgar a qualidade da simulação e fazer os ajustes que se fizerem necessários.
19 Fonte: https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na-c04617738#N10057
Exemplo 5.3 Sabendo que o pacote do Whatsapp é igual a 2,68 MB 20 e que λ = 483333,3 p/s21, utilize o
SF.MM1.cpp para avaliar a capacidade do servidor HPE ProLiant ML110 E5-2640v4, com vazão de 8,0 GT/s, em
processar as mensagens do Whatsapp.
Tamanho do pacote = 2,68 MB

Taxa de serviço:
GB pacote 8GB pacote 8 GB 8×1024 MB
μ=8 GT / s=8 = = pps= =3056,7 pps
s pacote pacote s 2,68 MB 2,68 MB
Configuração do SF.MM1.cpp: N = 5000, l = 483333.3, m = 3056.7
Resultados obtidos:
l = 483333,3
m = 3056,7
N = 5000
T = 1,6270
E(ic) = 0,0000
E(tf) = 0,8001
E(ts) = 0,0003
E(tsf) = 0,8005
E(nf) = 2490
DP(ic) = 0,0000
DP(tf) = 0,4637
DP(ts) = 0,0003
DP(tsf) = 0,4637
DP(nf) = 1437,4
U = 1,0000
Conclusão: a simulação resultou em U = 100%; sendo assim, o servidor HPE ProLiant ML110 E5-2640v4 não é
recomendado para o processamento de mensagens do Whatsapp.
20 Fonte: https://melhorplano.net/blog/whatsapp-internet/
21 Fonte: https://macmagazine.com.br/post/2018/11/14/cerca-de-29-milhoes-de-mensagens-sao-enviadas-por-minuto-no-whatsapp/
5.3 Revisão
5.4 Questões
1. Porque p0 não aparece na Tabela 5.2?

2. Interprete o gráfico feito a partir da tabela.
p ic ts cpf eps sps nf tf tes te

0 0 0 0 0 0 0 0 0 0
1 1 4 1 1 5 0 0 4 4
2 1 2 2 5 7 1 3 2 5
3 2 5 4 7 12 2 3 5 8
4 1 2 5 12 14 2 7 2 9
5 1 3 6 14 17 3 8 3 11
6 1 4 7 17 21 3 10 4 14
7 2 2 9 21 23 4 12 2 14
8 3 1 12 23 24 4 11 1 12
9 2 2 14 24 26 4 10 2 12
5.5 Exercícios
1. Compare os indicadores obtidos por simulação com os do correspondente modelo analítico sabendo que
λ = { 8 5 12 15 8 11 9 10 7 6 } e μ = { 11 10 9 12 9 11 14 8 9 10 }.
2. Pacotes que chegam em um Sistema de Fila M/M/1 com intervalo entre chegadas λ = { 8 5 12 15 8 11 9
10 7 6 } e tempos de serviço μ = { 11 10 9 12 9 11 14 8 9 10 }, simule 5 vezes e calcule a média e a
variância dos nos indicadores estimados (tf, tps e tsf)? Compare os indicadores obtidos por simulação (a)
com os do correspondente modelo analítico (b), utilize o erro relativo percentual 22, erp(%) = 100 (a-b)/b,
para comparação.
3. Repita o exercício 2 para as séries de dados: λ = { 5,7 7,8 8,0 7,7 5,0 6,1 8,0 2,6 3,2 3,4 7,7 7,6 7,2 3,2
7,6 3,3 6,8 6,8 } e μ = { 4,4 5,2 4,5 5,5 4,1 6,9 7,9 5,1 3,7 5,3 3,3 4,1 5,7 5,6 4,4 7,1 4,1 7,2 }
4. Repita o exercício 2 para as séries de dados: λ = { 22 22 31 13 12 29 32 19 17 20 13 23 13 20 27 18 22
1 20 14 19 6 22 17 27 24 } e μ = { 33 44 13 19 28 24 35 36 34 27 14 30 23 17 23 5 20 39 37 35 23 34
22 28 42 27 }
5. Repita o exercício 2 para as séries de dados: λ = { 24 28 20 24 28 15 24 24 23 16 28 28 32 23 22 21 19
27 28 23 36 24 } e μ = { 19 14 18 9 29 9 25 17 30 19 12 15 9 22 22 31 19 12 12 16 30 2 }
6. Segundo HTTP Archive (site que rastreia o desempenho da web e suas tecnologias), o tamanho médio de
uma página web em 03/2020 foi de 2 MB. A taxa de transferência de 2 MB com tecnologia 4G é de
menos de 1 s. Analise o Panorama de tráfego da RNP -
https://www.rnp.br/sistema-rnp/ferramentas/panorama-de-trafego - e estime a quantidade máxima de
usuário, com tecnologia 4G, que pode usar a web com estas taxas.
7. Altere o software SF.MM1.cpp de modo que sua disciplina da fila seja “Menor Tarefa Primeiro” (SJF –
shortest job first) – o pacote que tem o menor tempo de serviço será encaminhado ao Servidor. Ou seja,
implemente e software SF.M/M/1/∞/∞/SIF.cpp.
8. Compare os resultados dos softwares SF.MM1.cpp e SF.M/M/1/∞/∞/SIF.cpp.
22 Dadas duas medidas a e b, o erro relativo percentual (erp) de a em relação a erp (%) = 100 (a-b)/b, usado para indicar a percentagem
que a > b (erp > 0) ou que a < b (erp < 0) ou que a = b (erp=0).
6 VERIFICAÇÃO E VALIDAÇÃO DE MODELOS
Deve-se garantir a implementação correta de modelos computacionais para fins de

simulação para que eles possam representar sistemas do mundo real. A avaliação da
qualidade da simulação é medida pela proximidade dos resultados de um modelo
comparados com dados de sistemas do mundo real.
Figura 6.1 Da simulação de sistemas aos seus resultados.
Uma vez que uma série de suposições sobre o comportamento de sistemas do mundo real
são feitas no desenvolvimento de modelos, há duas etapas para medir sua qualidade:
• Verificação – verifica a correção da implementação, se o modelo computacional implementa as

suposições corretamente
• Validação – valida a representatividade dos pressupostos no modelo conceitual, se as premissas são
razoáveis
Como pode ser visto na Figura 6.2, validação e verificação são conceitos diferentes. A
verificação também pode ser chamada de depuração, ou seja, avalia se o modelo
computacional realiza o que se espera do modelo conceitual. A validação permite ajustar o
comportamento do modelo conceitual ao sistema do mundo real.
Figura 6.2 Relação entre os conceitos de validação e verificação, o mundo real e os modelos
conceitual e computacional.
Em relação à implementação das hipóteses e ao realismo dos pressupostos, um modelo pode

estar em qualquer uma das quatro categorias possíveis apresentadas na Tabela 6.1.
Tabela 6.1 Categorias dos modelos relativa à implementação das hipóteses e realismo dos
pressupostos.
Implementação das Hipóteses
Pressupostos
correta incorreta
realistas validado e verificado validado e não verificado
não realistas não validado e verificado não validado e não verificado
Apenas os modelos válidos e verificados podem ser capazes de representar sistemas do

mundo real, os demais não são confiáveis.
6.1 Técnicas de Validação de Modelo
Validação consiste em assegurar que os pressupostos utilizados, as simplificações adotadas,

o nível de detalhamento e o escopo do modelo conceitual estão de acordo e representam
adequadamente o sistema a ser simulado e que, se implementado corretamente, o modelo
computacional tenha comportamento e produza resultados semelhantes àquelas observados
nos sistemas do mundo real.
As técnicas de validação dependem dos pressupostos e, portanto, do sistema que está sendo
modelado. Assim, ao contrário de técnicas de verificação que são de aplicação geral, as
técnicas de validação utilizadas na simulação de um modelo podem não se aplicar a outro.
Validação do modelo consiste em validar os três aspectos-chave do modelo:
• Suposições
• Valores dos parâmetros de entrada e distribuições
• Valores de saída e conclusões
Cada um destes três aspectos pode ser submetido a um teste de validade, comparando-a
com o obtido a partir das seguintes possíveis três fontes:
é a forma mais prática e comum para validar um modelo. Os pressupostos
do modelo devem ser validados por especialistas. Os valores de entrada e
Intuição do
Especialista
distribuição devem ser discutidos e validados durante o desenvolvimento
do modelo. A saída deve ser validada, logo que existir um executável do
modelo
comparação com sistemas do mundo real é a maneira mais confiável e
preferida para validar um modelo de simulação. Suposições, valores de
Medidas Reais do
Sistema
entrada, valores de saída, cargas de trabalho, configurações e
comportamento do sistema devem ser comparados com os observados no
mundo real utilizando técnicas estatísticas
em alguns casos, é possível resolver analiticamente o modelo do sistema
sob hipóteses simplificadoras. Também pode ser possível determinar
Resultados
Teóricos
analiticamente as distribuições de entrada. Nesses casos, a semelhança de
resultados teóricos e os resultados da simulação é usada para validar o
modelo de simulação
Isto leva a nove testes de validação possíveis. Claro, pode não ser viável a utilização de
algumas dessas possibilidades. Por exemplo, medições reais do sistema podem estar
disponíveis ou não, resultados teóricos podem estar disponíveis ou não. O analista deve, pelo
menos, validar o modelo para configurações simples.
6.2 Técnicas de Verificação de Modelos
A verificação consiste em assegurar que o modelo computacional implementa corretamente

o modelo conceitual. A verificação de modelos de simulação é equivalente a retirar os bugs
de programas (debugging). Ela também busca identificar elementos que possam ocasionar o
mal funcionamento do modelo computacional.
A qualidade dos dados de entrada também é de extrema importância. Estes dados podem
ser utilizados com três finalidades básicas: construção do modelo conceitual, validação de
resultados e experimentação. Desta forma, se os dados de entrada do modelo estão
incorretos, não há como melhorar o modelo ou mesmo gerar resultados corretos.
As técnicas para a Verificação de Modelos podem ser vistas na Tabela 6.2.
Tabela 6.2 Técnicas para a Verificação de Modelos

A técnica consiste em eliminar a aleatoriedade, especificando distribuições

Modelos Determinísticos constantes (determinísticas) para que se possa facilmente determinar variáveis
de saída e, assim, depurar o software
o modelo pode ser executado com casos simples como, por exemplo, apenas um
pacote. Estes casos podem ser facilmente analisados e os resultados da
Executar Casos simulação podem ser comparados com os modelos analíticos. É claro, um
Simplificados modelo que funciona para casos simples não é garantido que funcione para os
casos mais complexos. Portanto, os testes devem ser tão complexos quanto
puderem ser analisados sem simulação
as saídas de rastreio são úteis na depuração de modelos pois são dados
Rastreio (Trace)
medidos, refletem o comportamento do sistema
simulações levam muito tempo para serem executadas. Gráficos on-line podem
exibir resultados para ajudar a manter o usuário informado sobre o estado da
Gráficos Online
simulação. Eles também são úteis para tornar a simulação mais interessante e
vender seus resultados para terceiros
consistem em executar a simulação várias vezes para valores ligeiramente
diferentes dos parâmetros de entrada. Para qualquer parâmetro, uma pequena
Teste de Continuidade mudança na entrada deve geralmente produzir apenas uma ligeira alteração na
saída. Toda mudança repentina na saída deve ser investigada. Muitas vezes, eles
são devidos a erros de modelagem
consistem em verificar se o modelo funciona para valores extremos (menores ou
maiores permitidos) do sistema, configuração, ou parâmetros de carga de
Testes de
trabalho. Por exemplo, modelo de estação de trabalho com multiprocessador e
Degenerescência
vários discos deve ser capaz de simular também uma única CPU sem disco
(diskless) mesmo que estas configurações não sejam válidas para o sistema
as sementes utilizadas na geração de números aleatórios não deve afetar o
Independência da
resultado final. Assim, o modelo deverá produzir resultados semelhantes para
Semente
diferentes valores de sementes, o que deve ser verificado
Exemplo 6.1 Geração de variáveis aleatórias exponenciais e determinísticas para simulação
A função abaixo gera variáveis aleatórias com distribuição exponenciais

double clSF::X( double p ){
double u = (rand()+1.0)/(RAND_MAX+2.0);
return -log(u)/p;
}
A função abaixo gera valores fixos com distribuição exponenciais (determinística)
double u = 0.5; // ou outra constante
return -log(u)/p;
}
Exemplo 6.2 Sementes variáveis e sementes fixas
A função abaixo inicia o gerador com sementes variáveis

clSF::clSF(){
srand(time(nullptr));
}
A função abaixo inicia o gerador com uma semente fixa, serve para avaliar a independência da semente
clSF::clSF(){
srand(123456890);
6.3 Revisão
6.4 Questões
1. Proponha uma metodologia para validar o Modelo Conceitual de Sistemas de Filas M/M/1 apresentado
anteriormente.
2. O que significa "modele simples - pense complicado" no contexto da Modelagem e Simulação.
3. O que significa "o incremento da qualidade obedece a Lei dos Rendimentos Decrescentes, já os custos
crescem exponencialmente" no contexto da Modelagem e Simulação.
6.5 Exercícios
1. Considere λ = { 5,7 7,8 8,0 7,7 5,0 6,1 8,0 2,6 3,2 3,4 7,7 7,6 7,2 3,2 7,6 3,3 6,8 6,8 } e μ = { 4,4 5,2
4,5 5,5 4,1 6,9 7,9 5,1 3,7 5,3 3,3 4,1 5,7 5,6 4,4 7,1 4,1 7,2 } e avalie o Modelo Conceitual de Sistemas
de Filas M/M/1 apresentado anteriormente usando: a) teste de continuidade, b) testes de
degenerescência, c) teste de consistência, e d) teste da independência da semente.
7 ANÁLISE DE RESULTADOS SIMULADOS
A simulação de modelos matemáticos de sistemas computacionais pode apresentar erros de

diferentes fontes. A começar pelos próprios modelos que, por construção, são representações
simplificadas de sistemas do mundo real; os erros inerentes ao processo da amostragem
também estão presentes nos parâmetros de suas entradas, que também são fontes de erros.
Ao simular estes modelos matemáticos em computadores, fazendo uso de números
aleatórios, são introduzidas variabilidade estatística nos resultados. Em resumo, não há como
controlar estas fontes de erros. Vale ressaltar que, apesar de tudo isso, ainda assim a
simulação dá bons resultados e pode ser utilizada de modo confiável.
Neste capítulo serão apresentadas técnicas estatísticas que permitem avaliar resultados de
simulações, sua qualidade, pertinência e assegurar seu uso. A análise de saída é um dos
aspectos mais importantes de qualquer estudo de simulação adequado e completo. Como os
processos de entrada da simulação são variáveis aleatórias, notadamente tempos entre
chegadas e tempos de serviços, deve-se considerar a saída da simulação também como
variável aleatória. Assim, simulações resultam apenas em estimativas de medidas de
desempenho do sistema. Esses estimadores são, eles mesmos, variáveis aleatórias sujeitos
ao erro amostral, o qual deve ser levado em conta para se fazer inferências válidas em
relação aos valores dos resultados simulados.
Na maioria dos sistemas simulados, os valores iniciais das suas variáveis de estado e de
saída podem apresentar grandes variações e mesmo oscilações, esta parte inicial é chamada
de estado transiente, após o que o sistema pode atingir um estado estável, denominado
estado estacionário, Figura 7.1. Há simulações cujo foco é o estado transiente e há outras
cujo interesse é o estado estacionário, há ainda aquelas que buscam estudar ambos estados.
Há também sistemas simulados que apresentam oscilações cíclicas, periódicas ou não.
Sistemas de comportamento caótico23 ou divergente são de pouco interesse prático em
sistemas computacionais.
23Séries caóticas e séries aleatórias são parecidas no sentido de que não possuem regularidade, a característica que
identifica o comportamento caótico é a sua dependência das condições iniciais, condições iniciais indistinguíveis podem
gerar comportamentos imprevisíveis, o que inviabiliza a repetibilidade bem como a previsibilidade do comportamento do
sistema
Figura 7.1 Indicação dos estados transiente e estacionário de uma simulação típica.
Pode-se identificar dois tipos de simulação em relação à análise da saída: simulações

terminais e de estado estacionário.
• Simulações terminais ou transientes – neste caso estuda-se o comportamento de curto prazo do

sistema, como a simulação de um sistema que é executado em um horário específico a cada dia, como
backup. Neste caso, a natureza do problema define explicitamente o número de pacotes a serem
simulados.
• Simulações de estado estacionário – neste caso estuda-se o comportamento a longo prazo do
sistema, como simular um serviço em nuvem que fica disponível continuamente, para a qual há
interesse em alguma medida de desempenho a longo prazo. Presumivelmente, esse comportamento de
estado estacionário é independente das condições iniciais da simulação.
As técnicas para analisar saídas de simulações terminais se baseiam no método de

replicações independentes, discutido abaixo.
Problemas adicionais surgem para simulações de estado estacionário e as seguintes etapas

na execução da simulação também devem consideradas:
• remoção de transientes – quantos pacotes iniciais devem ser descartadas para garantir que a
simulação chegue a um estado de equilíbrio?
• critério de parada – quantos pacotes serão necessários para executar a simulação?
7.1 Remoção de Transientes
Antes que uma simulação possa ser executada, devem-se definir valores iniciais para suas
variáveis de estado. Como, em princípio, os valores iniciais apropriados destas variáveis de
estado não são conhecidos, esses valores devem ser escolhidos arbitrariamente, utilizando-
se de alguns critérios como, por exemplo, iniciar uma Fila vazia e seu Servidor ocioso por
questões de conveniência. As condições iniciais de uma simulação podem ter uma influência
significativa nos seus resultados, podendo levar a erros na análise da saída de estado
estacionário.
Na maioria das simulações, apenas o desempenho em estado estacionário, isto é, o

desempenho depois que o sistema tenha atingido um estado estável, é de interesse. Nesses
casos, os resultados da parte inicial da simulação não devem ser incluídos nos cálculos finais.
Essa parte inicial é também chamada de estado transiente, Figura 7.1.
O problema de identificar o fim do regime transiente é chamado de remoção de transientes e

sua principal dificuldade é que não é possível definir exatamente o que constitui o estado
transiente e quando ele termina. Todos os métodos para a remoção de transientes são,
portanto, heurísticas. Os métodos mais importante são:
Tabela 7.1 Principias métodos para a remoção de transientes

o primeiro método é simplesmente usar execuções muito longas, ou seja, execuções que
são suficientemente longas para garantir que a presença de condições iniciais não
Execuções Longas
afetará o resultado. A desvantagens neste método é que é difícil garantir que o
comprimento da execução escolhido é suficiente
este e todos os métodos subsequentes são baseados no pressuposto de que a
variabilidade durante o estado de equilíbrio é menor do que durante o estado transiente,
o que geralmente é verdade. No método de truncamento, a variabilidade é medida em
Truncamento
termos de alcance mínimo e máximo de observações. Se uma trajetória mostrando
observações sucessivas em um gráfico, um intervalo de observações pode ser visto
quando a simulação estabilizar e entrar na fase estacionária
este método requer a execução de várias simulações muito longas. Cada simulação é
Replicações
chamada de replicação. A média das amostras finais retiradas de cada replicação é
Independentes
chamada de médias amostrais das replicações.
este método requer a execução de uma única simulação muito longa e dividi-la em
várias partes de igual tamanho. Cada parte é chamada de lote. A média de observações
Média de Lotes
em cada lote é chamada média de lote. Este método permite estudar a variação destas
médias em função do tamanho do lote
Antes de tratar da remoção de transientes, será estudado a estimação por intervalos de

confiança, utilizados por estes os métodos.
7.1.1 Estimação por Intervalos de Confiança
Um Intervalos de Confiança (IC) indica a confiabilidade de um parâmetro de uma população.

O IC está associada à incerteza que se tem a respeito da estimativa deste parâmetro.
Geralmente pode-se especificar a incerteza definindo-se um intervalo dentro do qual se

espera que o valor esteja com uma certa probabilidade. Este intervalo pode ser especificado
como (y-L) ≤ Y ≤ (y+L) ou Y = (y±L).
Se X = { x1, x2, ..., xn } são elementos de uma amostra aleatória, retirada de uma população,
o intervalo definido pela Equação 7.1 é denominado intervalo de confiança da média com
significância estatística α, com 1-α de probabilidade de contê-la, isto é, P[Li < m < Ls]=1-α.
s s s
(m−t 1−α ,n−1 ; m+t 1−α ,n−1 ) ou m∓t 1−α ,n−1 7.1
√n √n √n
s s
Li =m−t 1−α ,n−1 ; Ls =m+t 1−α ,n−1 7.2
√n √n
Em que t1-α,n-1 é ponto crítico da distribuição t-Student bicaudal, com n-1 graus de liberdade.
Os valores dos limites inferior Li e superior Ls (Equação 7.2) são calculados a partir das
observações X da amostra e 1-α é o nível de confiança associado ao intervalo.
Exemplo 7.1 Seis cargas de trabalho semelhantes foram utilizados em um sistema. As observações são {5,4
6,6 3,6 4,4 5,6}. Estime o intervalo de confiança da média destas observações com significância de 5%.
Confiança: 1-α = 1-0,05 = 0,95

Número de observações: n = 5
Média: m = ( 5,4 + 6,6 + 3,6 + 4,4 + 5,6 )/5 = 25,6 /5 = 5,1
Variância da amostra: [(5,4-5,5)2+(6,6-5,5)2+(3,6-5,5)2+(4,4-5,5)2+(5,6-5,5)2]1/2/5 = 1,3
Desvio padrão da amostra: s = 1,2

Intervalo de confiança: 5,1 ∓ t0,95;5ˣ1,2/61/2 = 5,1 ∓ 0,49t0,95;5
O valor t0,95;5 é o quantil 0,95 de uma variável t com cinco graus de liberdade, cujo valor 2,571 (bicaudal)
Intervalo de confiança: 5,1 ∓ 0,49ˣ2,571=(3,8;6,4)
O intervalo de confiança da média é (3,8;6,4) com 95% de confiança. Ou seja, se repetir estas observações
reiteradas vezes, serão obtidas médias com valores deste 3,8 até 6,4 em 95% dos casos. Pode-se observar
médias fora deste intervalo, acima e abaixo, em até 5% dos casos. Quanto maior o número de repetições mais
evidenciadas serão estas estatísticas.
xc
Para calcular xc = t1-α,n-1 deve-se resolver a equação integral ∫ f (x )dx=1−α em que

−x c
ν+1
1 x² − 2
f (x )= 1
(1+ ν ) é a distribuição t-Student com ν graus de liberdade e B é a função beta.
1
ν Β( , ν )
2
2 2
Considerando a simetria da distribuição t-Student, estes valores podem ser calculados a partir de
xc
∫ f ( x) dx= 1−α
2
ou obtidos de tabelas estatísticas (que são feitas com soluções destas equações
0
integrais).
7.1.2 Método das Médias de Lotes
Em geral, o Método de Médias de Lotes é usado para se estimar a variância ou calcular ICs
para a média μ de processos de estado estacionário. Ele consiste em dividir uma longa
rodada de simulação em um número de lotes contíguos e utilizar o Teorema Central do Limite
para supor que as médias de lotes sejam aproximadamente normais e iid.
Suponha que se particione {x1, x2, ..., xn} em l lotes contíguos, disjuntos, cada um com b
observações, sendo n = l⋅b. Assim, o i-ésimo lote, i ∈ [1,l], consiste nas variáveis aleatórias
b
1
x(i-1)b+1, x(i-1)b+2, ..., xi⋅b. A média do i-ésimo lote é zi = ∑ x(i−1)b+ j , a média amostral das b
b j=1
observações do lote i.
A Tabela 7.2 apresenta um quadro com os l lotes do Método de Média de Lotes organizadas
em linhas, cada lote com b pacotes organizados por coluna; num total de l x b pacotes. As
médias dos lotes são calculadas por linha.
Tabela 7.2 Quadro com os l lotes do Método de Média de Lotes, cada lote com b pacotes e
suas respectivas médias
Lote (i) Pacote (i+b) Média
1 x1 x2 ... xj ... xb z1
2 xb+1 xb+2 ... xb+j ... x2·b z2
... ... ... ... ... ... ... ...
i x(i-1)b+1 x(i-1)b+2 ... x(i-1)b+j ... xi·b zi
... ... ... ... ... ... ... ...
l x(l-1)b+1 x(l-1)b+2 ... x(l-1)b+j ... xl·b zl
l
1
Definindo o estimador V l = ∑
l−1 i=1
2
(z i −m) para as médias amostrais dos lotes,
l
1
m= ∑ zi . Se b é grande, então as médias amostrais dos lotes são aproximadamente
l i=1
Normais e iid. O valor de IC aproximado para a média populacional, μ, com 100(1-α)% de
confiança é μ ∈ m∓t 1−α ,l−1

√ Vl
l
.
O uso da média de lotes pode resultar em intervalos de confiança de baixa cobertura se os x i

não forem estacionários ou se as médias dos lotes não forem normais ou se as médias dos
lotes não forem independentes.
Para melhorar o problema do viés da iniciação, pode-se truncar alguns dos dados ou fazer
uma longa rodada. Além disso, a falta de independência ou de normalidade das médias dos
lotes pode ser contornada pelo aumento do tamanho do lote, b.
Exemplo 7.2 Calcule o Intervalo de Confiança bilateral da média da população a partir das Médias de Lotes
abaixo, α = 5%:
Lote Pacote Média
1 13,4 9,8 11,6 10,8 11,4
2 9,2 12,0 13,6 9,9 11,2
3 8,9 9,7 10,3 13,0 10,5
4 11,0 12,4 8,8 11,4 10,9
l=4
b=4
Cálculo dos zi:
z1 = (13,4 + 9,8 + 11,6 + 10,8)/4 = 11,4
z2 = (9,2 + 12,0 + 13,6 + 9,9)/4 = 11,2
z3 = (8,9 + 9,7 + 10,3 + 13,0)/4 = 10,5
z4 = (11,0 + 12,4 + 8,8 + 11,4)/4 = 10,9
Cálculo de m:
m = (11,4 + 11,2 + 10,5 + 10,9)/4 = 32,6/4 = 11,0
Cálculo de Vl:
Vl = [(11,4-11,0)2 + (11,2-11,0)2 + (10,5-11,0)2 + (10,9-11,0)2]/3 = 0,159
Cálculo de t1-0,5;3 = t0,95;3 = 3,1824 (valores tabelados – tabela bicaudal)
Cálculo do IC:
μ = 11,0 ∓ 3,1824 x (0,159/4)1/2 = 11,0 ∓ 3,1824 x 0,199 = 11,0 ∓ 0,634
Conclusão: média da população μ ∈ [10,4;11,6] com 95% de confiança.
O item 15.3 contém o software SF.MM1-ML-RI.cpp que implementa o Método da Média de

Lotes (MML).
7.1.3 Método de Replicação Independente (MRI)
O MRI estima V(m) através da realização de r rodadas de simulação independentes

(replicações) do modelo do sistema, em que cada replicação consiste em b pacotes
simulados. Para fazer replicações independentes, por exemplo, pode-se reiniciar cada
replicação com uma semente diferente.
b
1
Seja zi = ∑ x ij a média amostral da replicação i, onde x ij é a observação j da replicação i,
b j=1
para i ∈ [1,r] e j ∈ [1,b].
A Tabela 7.3 apresenta um quadro com as r rodadas do Método de Replicação Independentes

organizadas em linhas, cada rodada com b pacotes organizados por coluna; num total de r x
b pacotes. As médias das rodadas são calculadas por linha.
Tabela 7.3 Quadro com as r rodadas do Método de Replicação Independente, cada repetição
com b pacotes e suas respectivas médias
Pacote (j)
Repetição (i) Média
1 2 ... j ... b
1 x1,1 x1,2 ... x1,j ... x1,b z1
2 x2,1 x2,2 ... x2,j ... x2,b z2
... ... ... ... ... ... ... ...
i xi,1 xi,2 ... xi,j ... xi,b zi
... ... ... ... ... ... ... ...
r xr,1 xr,2 ... xr,j ... xr,b zr
Se cada rodada se inicia com as mesmas condições operacionais (como filas vazias e
servidores ociosos), então as médias amostrais das replicações {z 1, z2, ..., zr} são variáveis
aleatórias iid e, então, o estimador da variância das médias amostrais, V r, é
r r
1 1
V r= ∑
r−1 i=1
( zi −m) em que m= ∑ zi . Como as médias amostrais das replicações são
2
r i=1
iid, Vr, em geral, é muito menos viesado do que s 2/n para estimar Vr, desta forma Vr/r é um
estimador razoável para Vr. Além disso, se o número de observações por replicação, r, é
suficientemente grande, o Teorema Central do Limite afirma que as médias amostrais das
replicações são aproximadamente Normais e iid.
Assim, a estatística básica fornece um intervalo de confiança (IC) bilateral aproximado de
100(1-α)% de confiança para a média populacional, μ, μ ∈
Exemplo 7.3 Calcule o Intervalo de Confiança bilateral da média da população a partir das Replicações
m∓t 1−α ,r−1
√ Vr
r
.
Independente abaixo, α = 5%:

Pacote
Repetição (i) Média
1 2 3 4 5 6
1 12,2 14,3 9,7 11,4 13,1 11,3 12,0
2 11,4 10,2 9,3 13,1 12,0 11,8 11,3
3 10,7 11,1 13,0 10,4 11,3 11,4 11,3
4 13,2 10,4 10,7 11,5 9,2 10,2 10,9
r=4
b=6
Cálculo dos zi:
z1 = (12,2 + 14,3 + 9,7 + 11,4 + 13,1 + 11,3)/6 = 72,0/6 = 12,0
z2 = (11,4 + 10,2 + 9,3 + 13,1 + 12,0 + 11,8)/6 = 67,8/6 = 11,3
z3 = (10,7 + 11,1 + 13,0 + 10,4 + 11,3 + 11,4)/6 = 67,9/6 = 11,3
z4 = (13,2 + 10,4 + 10,7 + 11,5 + 9,2 10,2)/6 = 65,2/6 = 10,9
Cálculo de m:
m = (12,0 + 11,3 + 11,3 + 10,9)/4 = 45,48/4 = 11,4
Cálculo de Vr:
Vr = [(12,0-11,4)2 + (11,3-11,4)2 + (11,3-11,4)2 + (10,9-11,4)2]/3 = (0,396+0,005+0,003+0,254)/3 = 0,658/3 =
0,219
Cálculo de t1-0,05;3 = t0,95;3 = 3,1824 (valores tabelados – tabela bicaudal)
Cálculo do IC:
μ = 11,4 ∓ 3,1824 x (0,219/4)1/2 =11,4 ∓ 3,1824 x 0,230 = 11,4 ∓ 0,750
Conclusão: média da população μ ∈ [10,6;12,12] com 95% de confiança.
O item 15.3 contém o software SF.MM1-ML-RI.cpp que implementa o MRI.
7.2 Critério de Parada
A qualidade e confiança de uma simulação depende do intervalo de confiança dos seus

resultados. O software que faz a simulação pode utilizar como critério de parada valores
calculados de IC. Por outro lado, o número de simulações pode previamente determinado,
dado pelo valor N, neste caso o engenheiro é o responsável por validar os resultados.
7.2.1 Intervalo de Confiança como Critério de Parada
O critério de parada pela estimativa da variância utiliza o conceito de tamanho de amostras,

segue-se que a simulação deve ser executada até que o intervalo de confiança para a
resposta média se restrinja a um intervalo desejado, Figura 7.2. Se a média da amostra é m e
sua variância é V(m), o intervalo de confiança para a média é dada por m∓z 1−α V (m) em
que ∓z 1−α é o 1-α quantil de uma variável normal unitária.
Figura 7.2 Variação de E[tsf] versus o número de pacotes numa simulação de Sistema de Fila
M/M/1.
7.2.2 N como Critério de Parada
Um outro critério de parada, mais simples, é usar o Método RI ou o Método ML adotando um

valor muito grande para N como, por exemplo, N = 5000. Tendo em vista que o estado
estacionário pode ser alcançado para grandes valores de N, como mostrado na Figura 7.2. Ao
avaliar os ICs dos resultados obtidos, pode-se ajustar o valor de N.
Softwares que utilizam N fixo são mais simples do que os que usam intervalos de confiança
como critério de parada (N variável).
O valor de N grande o suficiente para que a simulação alcance o estado estacionário

depende de ρ (ρ=λ/μ). Pode-se observar experimentalmente que para ρ = 1 e N muito
grande, obtém valores de tsf e n f também muito grandes e U ≈ 1, tais simulações não são
úteis.
Pode-se usar N = 5000 para valores de ρ ≈ 0,75. Entretanto, recomenda-se fortemente

avaliar os valores dos intervalos de confiança dos resultados para julgar a qualidade das
simulações e fazer os ajuste do valor de N quando necessário.
7.3 Que Nível de Confiança Estatística Usar
Tem sido usado o nível de confiança estatística de 95%. Isso não deve levar a conclusão que
os níveis de confiança devem ser sempre altos. A escolha do nível de confiança baseia-se na
relação entre a perda se o parâmetro está fora do intervalo e o ganho se o parâmetro está
dentro do intervalo. Se a perda é alta em comparação com o ganho, os níveis de confiança
devem ser elevados. Se a perda é insignificante em comparação com o ganho, um nível de
confiança menor é suficiente.
Ao se deparar com um parâmetro que é significativo apenas no nível de confiança de 50%,

não deve ser assumido automaticamente que a confiança é baixa e que não se deve tomar
decisões com base nesse parâmetro. Da mesma forma, mesmo que um parâmetro seja
significativo ao nível de confiança de 99%, é possível que o nível de confiança não seja
suficientemente elevado se a perda devida à decisão errada for enorme.
O valor do nível de confiança deve ser contextualizado para cada caso.
7.4 Software SF.MM1-ML-RI.cpp
Foi desenvolvido o software SF.MM1-ML-RI.cpp, Algoritmo 15.2 do item 15.3 , para gerar
dados para os Métodos de Médias de Lotes (ML) de Replicações Independentes (RI).
O método RI requer dados de entrada: N, l, m, R (número de repetições) e P (percentagem de

N). O método RI gera um aquivo de saída com formato csv que pode ser manipulado por
planilhas, permitindo outras análises estatísticas. A Tabela 7.4 apresenta os resultados da
execução do SF.MM1-ML-RI.cpp.
Tabela 7.4 Resultado da execução da Replicação Independe do software SF.MM1-ML-RI.cpp

para N = 5000, l = 40, m = 50, R = 10 e P = 10.
R Pi Pf T E[tsf] E[nf] U
1 4500 4999 12,317 0,021 4,400 0,840
2 4500 4999 11,884 0,020 4,400 0,857
3 4500 4999 12,340 0,020 3,812 0,816
4 4500 4999 12,998 0,021 4,840 0,801
5 4500 4999 12,963 0,021 3,242 0,798
6 4500 4999 12,829 0,021 4,762 0,804
7 4500 4999 11,670 0,019 4,546 0,833
8 4500 4999 12,868 0,020 3,906 0,766
9 4500 4999 12,443 0,019 3,158 0,768
10 4500 4999 12,694 0,020 4,092 0,798
Em que Pi e Pf indicam pacotes iniciais e finais.
O método ML requer dados de entrada: l, m, L(número de lotes) e B(tamanho de lote). O

método ML gera um aquivo de saída com formato csv que pode ser manipulado por planilhas,
permitindo outras análises estatísticas. A Tabela 7.5 apresenta os resultados da execução do
SF.MM1-ML-RI.cpp.
Tabela 7.5 Resultado de uma execução da Média de Lotes do software SF.MM1-ML-RI.cpp para
l = 40, m = 50, L = 10 e B = 500.
B Pi Pf T E[tsf] E[nf] U
1 0 499 11,766 0,125 4,910 0,909
2 500 999 13,057 0,087 3,208 0,779
3 1000 1499 12,344 0,076 2,994 0,755
4 1500 1999 13,197 0,121 4,510 0,810
5 2000 2499 11,694 0,070 2,714 0,801
6 2500 2999 12,185 0,079 2,990 0,845
7 3000 3499 12,325 0,150 6,114 0,883

8 3500 3999 12,350 0,214 9,058 0,855
9 4000 4499 11,407 0,124 5,298 0,851
10 4500 4999 12,317 0,104 4,400 0,840
Em que Pi e Pf indicam pacotes iniciais e finais.
Por meio de planilha pode-se calcular os valores da média (m), desvio padrão (s), índice de
confiança (IC) para α = 5% e n = 10 e a covariância (Cov) dos resultados da Tabela 7.5,
conforme descrito abaixo, o que permite interpretar os resultados.
E[tsf] E[nf] U
m 0,1150 4,6196 0,8328
s 0,0434 1,9281 0,0469
IC 0,0311 1,3793 0,0336
Cov (%) 37,8 41,7 5,6
7.5 Revisão
7.6 Questões
1. Como os métodos RI e ML tratam os transientes?

2. Qual a utilidade de combinar os métodos RI e remoção de transientes?
3. Qual a utilidade de combinar os métodos ML e remoção de transientes?
7.7 Exercícios
1. Foram realizadas 4 rodadas de simulação, cada uma com 300 pacotes. Os dados de E[n f], E[tsf] e p0
estão listados abaixo. Calcule:
a) Intervalo de Confiança da média (μ) de E[nf], E[tsf] e U para α = 10%, α = 5% e α = 1%.

b) Intervalo de Confiança da variância (σ2) de E[nf], E[tps] e p0 para α = 10%, α = 5% e α = 1%.
E[nf]
i/j 1 2 3 4 5 6 7 8 9 10
1 4 3 2 2 3 3 3 4 3 2
2 7 5 4 5 5 4 4 7 4 4
3 12 18 7 2 8 8 6 9 10 6
4 20 3 13 5 4 12 9 7 8 9
E[tsf]
i/j 1 2 3 4 5 6 7 8 9 10
1 1.83 1.83 1.83 1.71 1.83 1.98 1.86 1.83 1.71 1.74
2 2.13 2.04 2.01 2.16 2.13 1.86 2.07 2.07 1.98 2.07
3 2.40 2.52 2.4 2.34 2.34 2.31 2.46 2.25 2.46 2.40
4 2.64 2.94 2.58 2.88 2.70 2.55 2.85 2.55 2.79 2.58
p0
i/j 1 2 3 4 5 6 7 8 9 10
1 0.373 0.346 0.385 0.374 0.362 0.347 0.397 0.340 0.408 0.475
2 0.256 0.252 0.341 0.264 0.275 0.355 0.330 0.231 0.322 0.374
3 0.181 0.108 0.200 0.171 0.216 0.230 0.197 0.195 0.149 0.278
4 0.116 0.008 0.165 0.033 0.022 0.134 0.078 0.116 0.031 0.190
2. Foi realizada uma rodada de simulação com 50 pacotes, abaixo relacionados. Calcule a) Intervalo de
Confiança da média (μ) de tsf para α = 10%, α = 5% e α = 1%.
p tsf p tsf p tsf p tsf p tsf p tsf

1 0,404 51 4,476 101 0,018 151 0,016 201 0,017 251 1,321
2 1,955 52 0,017 102 3,169 152 3,266 202 0,408 252 0,716
3 0,271 53 0,015 103 1,342 153 0,720 203 1,203 253 0,017
4 0,829 54 1,373 104 0,362 154 0,309 204 0,018 254 0,378
5 0,499 55 1,720 105 0,961 155 0,013 205 0,036 255 6,478
6 0,208 56 2,215 106 0,225 156 1,066 206 1,989 256 0,164
7 2,173 57 0,281 107 0,548 157 0,012 207 0,205 257 0,212
8 2,431 58 0,432 108 0,017 158 0,898 208 0,101 258 0,057
9 2,904 59 0,059 109 0,301 159 0,067 209 0,012 259 1,737
10 0,033 60 0,391 110 3,862 160 0,189 210 2,285 260 0,820
11 3,395 61 0,011 111 0,090 161 0,037 211 0,913 261 6,078
12 0,026 62 0,123 112 5,624 162 1,260 212 0,259 262 0,097
13 0,127 63 0,160 113 1,156 163 0,092 213 0,554 263 0,126
14 0,059 64 2,769 114 0,044 164 0,009 214 0,090 264 0,137
15 0,098 65 2,005 115 0,082 165 0,038 215 0,045 265 0,778
16 2,198 66 1,549 116 1,832 166 1,421 216 3,903 266 0,491
17 0,024 67 0,030 117 0,018 167 0,075 217 0,037 267 0,029
18 0,010 68 0,058 118 0,018 168 0,051 218 0,014 268 0,446
19 0,130 69 0,015 119 0,729 169 0,042 219 0,891 269 0,960
20 0,300 70 0,016 120 0,049 170 0,362 220 0,114 270 0,101
21 0,145 71 0,053 121 0,132 171 0,809 221 0,332 271 0,056
22 0,792 72 0,136 122 0,456 172 0,015 222 0,245 272 2,138
23 0,019 73 2,812 123 0,112 173 0,046 223 0,236 273 3,339
24 5,175 74 4,056 124 0,112 174 5,506 224 0,094 274 1,143
25 0,038 75 0,010 125 0,390 175 3,050 225 2,759 275 0,017
26 0,256 76 0,883 126 0,014 176 3,730 226 0,475 276 6,556
27 1,411 77 1,156 127 0,602 177 0,559 227 6,327 277 0,026
28 0,023 78 0,074 128 2,128 178 0,010 228 0,010 278 0,336
29 0,155 79 4,526 129 1,431 179 2,912 229 3,210 279 1,251
30 0,195 80 0,026 130 1,960 180 0,143 230 0,081 280 1,006
31 4,262 81 0,088 131 0,764 181 0,359 231 0,061 281 3,183
32 1,030 82 0,010 132 5,004 182 6,021 232 0,052 282 0,091
33 3,494 83 0,053 133 0,093 183 0,236 233 0,582 283 0,036
34 3,851 84 0,014 134 0,430 184 0,009 234 0,016 284 0,917
35 0,285 85 4,128 135 1,163 185 0,128 235 0,013 285 0,013
36 5,334 86 0,190 136 2,220 186 0,055 236 0,537 286 0,026
37 0,110 87 0,092 137 1,041 187 1,142 237 0,018 287 0,410
38 0,023 88 0,081 138 0,011 188 0,023 238 5,487 288 0,009
39 0,747 89 0,352 139 2,125 189 2,876 239 0,018 289 0,126
40 2,567 90 0,901 140 0,014 190 0,055 240 2,864 290 0,022
41 0,100 91 3,335 141 4,777 191 2,458 241 3,516 291 0,009
42 2,170 92 3,692 142 6,056 192 0,429 242 4,778 292 0,016
43 0,186 93 0,129 143 0,081 193 0,016 243 5,460 293 0,057
44 2,922 94 0,033 144 0,418 194 5,417 244 1,292 294 0,022
45 1,588 95 0,016 145 0,146 195 0,126 245 0,507 295 0,422
46 0,049 96 0,010 146 0,526 196 0,223 246 4,404 296 2,829
47 0,492 97 1,631 147 0,365 197 0,468 247 0,035 297 0,364
48 1,356 98 0,304 148 0,021 198 0,230 248 0,115 298 0,020
49 0,353 99 0,775 149 0,052 199 0,022 249 0,029 299 0,028
50 0,400 100 0,045 150 0,252 200 0,125 250 0,804 300 0,242
3. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de simulação, cada uma
com M eventos e calcule os Intervalos de Confiança da média (μ) e da variância (σ 2) de nf, tf, tps e tsf
para α = 10%, α = 5% e α = 1% nos casos:
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000
4. Compare estes resultados.

5. Modifique o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de simulação, cada
uma com M eventos e calcule os Intervalos de Confiança da média (μ) e da variância (σ 2) de p0 para α =
10%, α = 5% e α = 1% nos casos:
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000

7. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar rodadas de simulação com N eventos
e calcule os Intervalos de Confiança da média (μ) e da variância (σ 2) de ic, ts, nf, p0, tf e tsf para α =
10%, α = 5% e α = 1% nos casos:
a) N = 1000
b) N = 10000
c) N = 100000

8 SIMULAÇÃO DE SISTEMAS COMPUTACIONAIS
São diversos os sistemas computacionais, a Figura 8.1 representa um exemplo simples de um

sistema de computação, constituído por um Servidor Web (Sw) conectado à Internet por meio
de um Switch (S). Neste sistema, mensagens da Internet são recebidas pelo Switch que as
envia para o Servidor Web. O Servidor Web recebe estas mensagens, processa-as, e as
enviam de volta para o Switch. O Switch recebe as mensagens do Servidor Web e as envia de
volta à Internet.
Considerando o sistema computacional da Figura 8.1, se a taxa de serviços de chegada no

Switch for menor ou igual que sua capacidade de processamento então ele enviará os
serviços ao Servidor Web num fluxo contínuo senão serviços serão armazenados na memória
do Switch para posterior processamento. Neste caso, diz-se que os serviços estão sendo
colocados em uma fila do Switch. Semelhante raciocínio é válido para os demais elementos
do sistema.
Figura 8.1 Sistema computacional, Servidor Web (Sw) conectado a rede internet por meio de
um Switch (S).
O sistema computacional da Figura 8.1 pode ser modelado por dois sistemas de filas em série
como mostrado na Figura 8.2, o primeiro para o processo de chegada no Switch e o segundo
para o Servidor Web. A taxa de entrada de serviços do Switch é a que chega da Internet.
Após processar os serviços, o Switch os envia para o Servidor Web. A taxa de entrada de
serviços no Servidor Web é a taxa de saída do Switch. Após processar os serviços, o Servidor
Web os envia para o Switch. A taxa de entrada de serviços no Switch é a mesma que sai do
Servidor Web. Por fim, após processar os serviços, o Switch os envia para a Internet.
Figura 8.2 Modelo de um sistema computacional por meio de filas.

Pode-se modelar os elementos de sistemas computacionais por meio de uma rede de

sistemas de filas, um sistema de filas para cada elemento.
A arquitetura de um sistema de hardware é mostrado na Figura 8.3, um diagrama de blocos

de nível de sistema do Sun Fire X4150 Server com Serial Attached SCSI – SAS. Estes
servidores foram projetados para fornecer o melhor desempenho com alta confiabilidade e
baixo consumo de energia. Eles possuem múltiplos processadores que se conectam a um
controlador de memória Northbridge Hub (MCH) que, por sua vez, se conecta a um
Southbridge I/O (IOH) e seus subsistemas (Sun Microsystems, 2016).
Figura 8.3 Diagrama de blocos do Sun Fire X4150 Server com Serial Attached SCSI – SAS (Sun
Microsystems, 2016).
A simulação de sistemas computacionais permite estudar seu comportamento de modo

detalhado e fazer previsões sobre o mesmo.
8.1 Modelo de Rede de Sistemas de Fila (RSF)
Os modelos de Rede de Sistemas de Fila (RSF) representam sistemas computacionais por

meio de Sistemas de Filas (SF) interconectadas e com topologia bem definida. As RSFs
A/B/c/K/m/Z podem ser simuladas por computador e, inicialmente será apresentado o modelo
conceitual de uma RSF com SF M/M/1 e, em seguida, o seu modelo computacional será
discutido e implementado em C++. A dinâmica temporal de uma RSF típica será apresentada
no formato de tabelas permitindo o acompanhamento de suas variáveis de entrada, de
estado e de saída.
No Capítulo 2 foram apresentados os Modelos Conceitual e Computacional de Sistemas de

Fila M/M/1. A diferença principal entre os modelos de um simples SF e RSFs é que, por haver
mais de um SF, o primeiro SF terá dados de entrada e, a partir do segundo SF, os dados de
entrada serão os dados de saída do SF anterior, Figura 8.4.
Figura 8.4 Rede de Sistemas de Fila indicando o fluxo de dados de entrada (ic) do primeiro
Sistema de Fila e a sua saída (is – intervalo entre saída) como entrada para o próximo
Sistema de Fila.
8.2 Modelo Conceitual de RSF
Um Modelo Conceitual de uma RSF de Filas M/M/1 será apresentado e discutido e, a partir
dele, modelos envolvendo Filas M/M/c/K/m podem ser derivados dele.
Nos Sistemas de Fila das RSFs, os pacotes chegam um por vez e são processados igualmente
um por vez. Desta forma, os Sistemas de Fila de uma RSF possuem três variáveis básicas:
1. taxa de chegada (λ) e seu correspondente intervalo entre chegadas (ic), ic = 1/E[λ]
2. taxa de serviço (μ) e seu correspondente tempo de serviço (ts), ts = 1/E[μ]
3. taxa de saída (γ) e seu correspondente intervalo entre saídas (is), is = 1/E[γ]
A Figura 8.5 ilustra o Modelo Conceitual de um Sistemas de Fila M/M/1 de uma RSF. Conforme
enfatizado, a saída dos SFs torna-se importante no caso de RSFs.
Figura 8.5 Modelo conceitual de um Sistemas de Fila em rede.
Numa Rede de Sistemas de Filas (RSF), os pacotes deve ser processados em cada um dos
Sistemas de Filas, sequencialmente, de acordo com a arquitetura da rede. A saída do
Servidor anterior serve de entrada para a Fila do próximo Sistema de Fila. Os dados de
entrada da Rede de Filas são os intervalos entre chegadas na primeira Fila e os dados de
saída de cada Servidor do Sistema de Filas. Os parâmetros da Rede de Filas são:
• os valores de A/B/c/K/m/Z de cada SF

• sequência dos pacotes, r
• número de pacotes para simular, N
• λ do primeiro SF
• μ de cada SF, d
Será utilizado um estudo de caso da Figura 8.6 para apresentar o modelo conceitual de
Redes de Sistemas de Filas tendo em vista que há muitas combinações possíveis de Sistemas
de Filas. A partir de deste estudo de caso, pode-se generalizar o modelo proposto.
Figura 8.6 Esquema do estudo de caso de uma Rede de Sistemas de Fila.
A RSF da Figura 8.6 possui 4 SF, numeradas de 0 a 3: SF 0, SF1, SF2 e FS3. Os parâmetros desta
rede são:
• os SF da RSF são M/M/1

• sequência dos pacotes: 0 → 1, 1 → 2, 2 →1, 1→ 3, 3→ 0, logo r = [ 0, 1, 2, 1, 3, 0 ]
• número de pacotes, N (definido pelo usuário)
• λ0 e m = [ μ0, μ1, μ2, μ3 ]
Em resumo, os parâmetros da RSF da Figura 8.6, para 5000 pacotes: N = 5000, l0, m = [ m0,
m1, m2, m3 ] e r = [ 0, 1, 2, 1, 3, 0 ].,
Nota sobre a sequência de pacotes numa RSF
O nível de detalhes do modelo de sequência dos pacotes é a visão de pior caso, à maneira da
Ciência da Computação Clássica. A trajetória de um pacote numa rede pode variar com a
natureza do próprio pacote e da rede, assim há várias sequências possíveis para os pacotes.
Visando uma modelagem simples sem perder precisão, adotou-se o critério de pior caso:
todos pacotes seguem a maior sequência possível na rede. Esta abordagem simplifica:
• a compreensão do problema
• o modelo conceitual
• o modelo computacional
Esta abordagem também é a favor da segurança da solução uma vez que superestima os
resultados mas não dispensa a supervisão de engenheiro após a implantação da solução,
para ajustes que se fizerem necessários.
8.3 Valores Iniciais da Simulação de RSF
A condição mais simples para iniciar a simulação de uma RSF é zerar o cronômetro com as
Filas vazias e os Servidores ociosos. Ou seja, zerar tudo, o cronômetro e o número de pacotes
na RSF.
Como há uma correspondência entre o vetor m e o número de SF, o número de elementos de

m é igual ao número de SF, pode-se escrever que SFi está relacionado com mi. Pode-se
pensar também que mi é o mesmo que m[i]. O índice i será associado aos Sistema de Fila.
Como visto na Figura 8.4, uma RSF é um encadeamento de SF, a sequência dos pacotes
neste encadeamento é dado pelo vetor r, que define o roteamento dos pacotes desde a
entrada até a saída do sistema.
Observe que não há uma correspondência entre o número de SF e o número de elementos de

r. O vetor r determina o caminho que um pacote percorre na RSF, uma rota longa tem uma
sequência com várias SF, incluindo SF repetidas.
Um pacote entra na RSF no r0, segue para o r1 e assim por diante, percorrendo todo vetor r,
ou seja: r0 → r1 → r2 → … → ri → … Pode-se pensar também que ri é o mesmo que r[i]. O índice
i será associado ao roteamento.
Observe que ri é algum dos SF de RSF, para este texto r 0 é o SF0. Vale ressaltar que r0 pode
ser um outro SF, depende apenas da configuração da RSF.
8.4 Roteamento do Primeiro Pacote (p=0)
Os pacotes percorrem uma RSF de acordo com o encadeamento dado pelo vetor r. Os
pacotes são processados em cada SF da rede, nos quais são calculados seus eventos e
demais variáveis de estado.
O primeiro pacote (p=0) que entra na RSF requer tratamento diferenciado pois não há pacote
antes dele. Por outro lado, r0 também requer tratamento diferenciado pois não há SF antes
dele.
O r0.ic0 é duplamente diferenciado pois é o primeiro pacote (p = 0) no primeiro SF(r 0). O

intervalo entre chegadas do primeiro pacote (ic0) no primeiro SF da RSF(r0) é r0.ic0 = X(r0.λ).
Em resumo, os valores do pacote p = 0 e r0 são calculados como descrito abaixo:

• r0.ic0 = X(r0.λ)
• r0.cpf0 = r0.ic0
• r0.eps0 = r0.cpf0
• r0.sps0 = r0.eps0 + X(r0.μ)
• r0.is0 = r0.sps0
Ao sair de r0 o primeiro pacote segue o encadeamento dado pelo vetor r e, generalizando, os
valores de p = 0 e ri, i > 0, são calculados como descrito abaixo:
• ri.ic0 = ri-1.is0
• ri.cpf0 = ri.ic0
• ri.cpf0 = ri.cpf0
• ri.sps0 = ri.eps0 + X(r0.μ)
• ri.is0 = ri.sps0
Observe que apenas ri.ic0 é feito com dados do SF que o antecede, representado por ri-1. Os
demais são calculados com dados do próprio SF, representado por ri.
Para fins computacionais, uma maneira prática de tratar o pacote p = 0 é fazer:
ri.ic0 = ri.cpf0 = ri.epsf0 = ri.sps0 = ri.is0 = ri.nf0 = 0, i ≥ 0.

8.5 Roteamento dos Demais Pacotes (p>0)
Os pacotes que sucedem o primeiro na RSF, podem ser tratados de modo genérico como p, p
∊ (0,N).
O pacote p, p > 0, que entra na RSF no r 0 é especial no tocante a r0.icp pois não tem SF que o
antecede e, neste, r0.icp = X(r0.λ), caso contrário r0.icp = ri-1.isp, ou seja, o valor de is do SF
que o antecede. Os demais valores destes pacotes dependem do mesmo SF e do pacote
anterior.
Generalizando, os valores de p, p > 0 e ri, i ≥ 0, são calculados como descrito abaixo:

• ri.icp = i > 0 ? ri-1.isp : X(ri.λ)
• ri.cpfp = ri.icp + ri.cpfp-1
• ri.epsp = ri.cpfp > ri.spsp-1 ? ri.cpfp : ri.spsp-1
• ri.spsp = ri.epsp + X(ri.μ)
• ri.isp = ri.spsp + ri.spsp-1
Observe que apenas ri.icp (i > 0) é feito com dados do SF que o antecede, representado por ri-
1. Os demais valores são calculados com dados do próprio SF, representado por r i,
utilizando dados do próprio pacote (ri.icp, ri.cpfp, ri.epsp, ri.spsp) ou de pacotes anteriores do
mesmo SF (ri.cpfp-1, ri.spsp-1).
O cálculo de nf de cada SF é feito de forma semelhante ao Sistema de Fila Simples.
8.6 Revisão de RSF
Configuração das RSF M/M/1:
N, SF = [0, 1, 2, …, s, …], λ0, μ = [μ0, μ1, μ2, …, μs, …], r = [r0, r1, r2, …, ri, …], ri ∊ SF
r
Pacote
0 i
r0.ic0 = X(r0.λ) ri.ic0 = ri-1.is0
r0.cpf0 = r0.ic0 ri.cpf0 = ri.ic0
0 r0.eps0 = r0.cpf0 ri.eps0 = ri.cpf0
r0.sps0 = r0.eps0 + X(r0.μ) ri.sps0 = ri.eps0 + X(r0.μ)
r0.is0 = r0.sps0 ri.is0 = ri.sps0
r0.icp = X(r0.λ) ri.icp = ri-1.isp
r0.cpfp = r0.icp + r0.cpfp-1 ri.cpfp = ri.icp + ri.cpfp-1
p > 0 r0.epsp = r0.cpfp > r0.spsp-1 ? r0.cpfp : r0.spsp-1 ri.epsp = ri.cpfp > ri.spsp-1 ? ri.cpfp : ri.spsp-1
r0.spsp = r0.epsp + X(r0.μ) ri.spsp = ri.epsp + = X(ri.μ)
r0.isp = r0.spsp + r0.spsp-1 ri.isp = ri.spsp + ri.spsp-1
for( int p = 1; p < N; p++ )

for( int i = 0; i < r.size(); i++ )
Empacota(r[i]);
9 MODELO COMPUTACIONAL DE REDES DE SISTEMAS DE FILAS
O modelo computacional de RSF de Sistemas de Fila M/M/1 pode ser visto na Tabela 9.1. Ele é
constituído por três classes, a saber: clPacote, clSF e clRSF. A classe clRSF possui um
vetor de classes clSF e clSF possui um vetor de classes clPacote. O método Configurar
configura os dados da RSF, Iniciar calcula os valores iniciais dos SFs, Simular executa as
simulações fazendo uso do método Empacotar. Por fim, Nf calcula os valores de nf de cada
SF. O cálculo das estatísticas não está implementado.
Tabela 9.1 Classe clRSFMM1 do Modelo Computacional dos Sistemas de Fila M/M/1
clPacote
ic clRSF
cpf r[]
eps clSF SF[]
sps X(p)
is Iniciar( l, m[], r[] )
nf Empacotar(i)
clSF Simular(N)
l Nf()
m Estatistica()
clPacote Pacote[]
Veja mais detalhes a seguir:
Tabela 9.2 Descrição das classes do Modelo Computacional dos Sistemas de Fila M/M/1
clPacote pacotes dos SF com as variáveis de estado ic, cpf, eps, sps, is e nf
clSF são os SF da RSF, seus parâmetros l e m, e o vetor Pacote
representa a RSF, seus métodos e os vetores r e SF
• Iniciar – configura a RSF e o insere o primeiro pacote nos SFs

clRSF
• X – calcula os valores de ic e ts dos pacotes simulados
• Empacotar – insere um novo Pacote no i-ésimo SF
• Simular – simula os pacotes de 1 a N-1 dos SFs
O Algoritmo 9.1 implementa em C++ o modelo computacional básico de uma RSF M/M/1.
Algoritmo 9.1 Código básico em C++ para simulação de Redes de Sistemas de Fila M/M/1
//-------------------------------------------------------------------------------
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
class clPacote{
public:
int nf;
double ic, cpf, eps, sps, is;
};
class clSF{
public:
double l, m;
vector<clPacote> Pacote;
};
class clRSF{
private:
vector<int> r;
vector<clSF> SF;
double X ( double );
void Nf ( void );
public:
clRSF ( void );
void Iniciar ( double, vector<double>, vector<int> );
void Simular ( int );
};
clRSF::clRSF( void ){
}
double clRSF::X( double p ){
return -log(u)/p;
}
void clRSF::Iniciar( double l, vector<double> m, vector<int> r ){
this->r = r;
SF.clear();
for( size_t s = 0; s < m.size(); s++ ){
clSF X;
X.l = l;
X.m = m[s];
X.Pacote.clear();
SF.push_back(X);
}
for( size_t s = 0; s < r.size(); s++ ) // p = 0
SF[r[s]].Pacote.push_back({0,0,0,0,0,0,0});
}
void clRSF::Empacotar( int i ){
clPacote P, Pa;
if( i > 0 ){
Pa = SF[r[i-1]].Pacote[ SF[r[i-1]].Pacote.size()-1 ];
P.ic = Pa.is;
}
else P.ic = X( SF[r[i]].l );
Pa = SF[r[i]].Pacote[ SF[r[i]].Pacote.size()-1 ];
P.cpf = P.ic + Pa.cpf;
P.eps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
P.sps = P.eps + X(SF[r[i]].m);
P.is = P.sps - Pa.sps;
SF[r[i]].Pacote.push_back(P);
}
void clRSF::Simular( int N ){
for( int p = 1; p < N; p++ )
for( size_t i = 0; i < r.size(); i++ )
Empacotar(i);
Nf();
}
void clRSF::Nf( void ){
for( size_t s = 0; s < SF.size(); s++ )
for( size_t p = 1; p < SF[s].Pacote.size(); p++ ){
size_t c = p-1;
SF[s].Pacote[p].nf = 0;
while( SF[s].Pacote[p].cpf < SF[s].Pacote[c].sps ){

SF[s].Pacote[p].nf += 1;
c--;
}
}
}
int main( void ){
int N = 5000;
vector<int> r = { 0, 1, 2, 3, 0 };
double l = 500;
vector<double> m = { 600, 700, 800, 900 };
clRSF RSF;
RSF.Iniciar(l,m,r);
RSF.Simular(N);
return 0;
}
O software RSF.MM1.cpp, escrito em C++, implementa o modelo computacional completo de

uma RSF M/M/1 e pode ser visto no Algoritmo 15.3 item 15.4 .
A arquitetura do sistema é definida pelas variáveis l, m e r. A primeira indica a taxa de

chegada na RSF, a segunda é o desempenho de cada Servidor dos SFs e a última indica o
caminho percorrido pelos pacotes dentro da arquitetura definida.
As variáveis utilizadas no software RSF.MM1.cpp estão sumarizadas na Tabela 9.3.
Tabela 9.3 Variáveis utilizadas no software RSF.MM1.cpp

Nome Descrição
Entradas
N Número de pacotes
l Taxa de chegadas na RSF
m Vetor de taxas de serviço dos SF
r Ordem de visitas dos pacotes
Variáveis
ic Intervalo entre chegadas de pacotes na Fila
is Intervalo entre saídas de pacotes do Servidor
Eventos
cpf Tempo da chegada de pacotes na Fila
eps Tempo da chegada de pacotes no Servidor
sps Tempo da saída de pacotes no Servidor
Estatísticas
nf Comprimento da Fila
tsf Tempo no Sistema de Fila
U Utilização do Servidor
T Duração da simulação
Os resultados de uma simulação, feita com o software RSF.MM1.cpp estão apresentados na

Tabela 9.4. Devido ao uso de números aleatórios, os resultados da simulação podem variar a
cada execução do software.
Tabela 9.4 Resultado da execução do software RSF.MM1.cpp para N = 10, l = 60 e m = { 30,

30, 30, 30 } e r = { 0, 1, 2, 1, 3, 2, 1, 3, 2, 1, 0 }
Simulacao de Rede de Sistemas de Fila M/M/1

RSF Tabela
Numero de SF:4
Sequencia:0-1;1-2;2-1;1-3;3-2;2-1;1-3;3-2;2-1;1-0;
RSF l m
0 60,000 30,000
1 - 30,000
2 - 30,000
3 - 30,000
SF: 0
p ic cpf eps sps nf is
0 0,000 0,000 0,000 0,000 0 0,000

1 0,000 0,000 0,000 0,000 0 0,000
2 0,022 0,022 0,022 0,065 0 0,065
3 0,148 0,171 0,171 0,189 0 0,124
4 0,019 0,190 0,190 0,210 0 0,021
5 0,028 0,218 0,218 0,239 0 0,029
6 0,017 0,235 0,239 0,265 1 0,026
7 0,001 0,236 0,265 0,280 2 0,015
8 0,004 0,240 0,280 0,372 2 0,093
9 0,102 0,342 0,372 0,387 1 0,014
10 0,009 0,351 0,387 0,415 2 0,028
11 0,038 0,389 0,415 0,421 1 0,006
12 0,011 0,400 0,421 0,499 2 0,078
13 0,014 0,414 0,499 0,548 3 0,048
14 0,004 0,418 0,548 0,548 3 0,001
15 0,075 0,493 0,548 0,554 3 0,005
16 0,004 0,497 0,554 0,595 4 0,041
17 0,127 0,624 0,624 0,629 0 0,034
18 0,013 0,637 0,637 0,693 0 0,064
19 0,107 0,744 0,744 0,838 0 0,144
SF: 1
0 0,000 0,000 0,000 0,000 0 0,000
1 0,000 0,000 0,000 0,000 0 0,000
2 0,000 0,000 0,000 0,000 0 0,000
3 0,000 0,000 0,000 0,000 0 0,000
4 0,065 0,065 0,065 0,068 0 0,068
5 0,073 0,138 0,138 0,146 0 0,078
6 0,242 0,380 0,380 0,385 0 0,239
7 0,140 0,520 0,520 0,533 0 0,148
8 0,021 0,541 0,541 0,553 0 0,020
9 0,015 0,556 0,556 0,560 0 0,007
10 0,049 0,605 0,605 0,633 0 0,073
11 0,001 0,605 0,633 0,661 1 0,028
12 0,026 0,631 0,661 0,723 2 0,062
13 0,061 0,692 0,723 0,728 1 0,005
14 0,008 0,700 0,728 0,799 2 0,071
15 0,051 0,752 0,799 0,800 1 0,001
16 0,093 0,845 0,845 0,866 0 0,066
17 0,084 0,929 0,929 0,974 0 0,109
18 0,125 1,054 1,054 1,073 0 0,098
19 0,068 1,122 1,122 1,174 0 0,102
20 0,028 1,150 1,174 1,260 1 0,086
21 0,117 1,266 1,266 1,295 0 0,035
22 0,013 1,279 1,295 1,303 1 0,008
23 0,002 1,281 1,303 1,342 2 0,038
24 0,078 1,359 1,359 1,361 0 0,019
25 0,043 1,402 1,402 1,409 0 0,048
26 0,119 1,521 1,521 1,539 0 0,130
27 0,032 1,553 1,553 1,553 0 0,014
28 0,001 1,554 1,554 1,561 0 0,008
29 0,020 1,574 1,574 1,588 0 0,026
30 0,224 1,798 1,798 1,848 0 0,260
31 0,101 1,898 1,898 1,922 0 0,075
32 0,041 1,940 1,940 1,955 0 0,032
33 0,009 1,949 1,955 2,002 1 0,048
34 0,020 1,969 2,002 2,011 1 0,009
35 0,107 2,076 2,076 2,138 0 0,127
36 0,064 2,140 2,140 2,168 0 0,029
37 0,036 2,176 2,176 2,186 0 0,018
38 0,014 2,190 2,190 2,211 0 0,026
39 0,042 2,232 2,232 2,318 0 0,107
SF: 2
0 0,000 0,000 0,000 0,000 0 0,000
1 0,000 0,000 0,000 0,000 0 0,000
2 0,000 0,000 0,000 0,000 0 0,000

3 0,068 0,068 0,068 0,073 0 0,073
4 0,167 0,235 0,235 0,315 0 0,242
5 0,165 0,400 0,400 0,455 0 0,140
6 0,020 0,420 0,455 0,470 1 0,015
7 0,004 0,424 0,470 0,519 2 0,049
8 0,073 0,497 0,519 0,520 1 0,001
9 0,062 0,559 0,559 0,580 0 0,061
10 0,018 0,578 0,580 0,589 1 0,008
11 0,051 0,629 0,629 0,640 0 0,051
12 0,066 0,694 0,694 0,724 0 0,084
13 0,154 0,848 0,848 0,849 0 0,125
14 0,056 0,904 0,904 0,917 0 0,068
15 0,086 0,990 0,990 1,034 0 0,117
16 0,049 1,039 1,039 1,047 0 0,013
17 0,001 1,040 1,047 1,048 1 0,002
18 0,019 1,059 1,059 1,091 0 0,043
19 0,036 1,095 1,095 1,210 0 0,119
20 0,128 1,223 1,223 1,242 0 0,032
21 0,008 1,231 1,242 1,262 1 0,020
22 0,202 1,432 1,432 1,486 0 0,224
23 0,112 1,544 1,544 1,587 0 0,101
24 0,032 1,577 1,587 1,596 1 0,009
25 0,022 1,598 1,598 1,616 0 0,020
26 0,104 1,702 1,702 1,723 0 0,107
27 0,029 1,731 1,731 1,758 0 0,036
28 0,028 1,759 1,759 1,772 0 0,014
29 0,030 1,789 1,789 1,814 0 0,042
SF: 3
0 0,000 0,000 0,000 0,000 0 0,000
1 0,000 0,000 0,000 0,000 0 0,000
2 0,078 0,078 0,078 0,167 0 0,167
3 0,239 0,317 0,317 0,332 0 0,165
4 0,007 0,324 0,332 0,336 1 0,004
5 0,073 0,397 0,397 0,409 0 0,073
6 0,005 0,402 0,409 0,427 1 0,018
7 0,071 0,473 0,473 0,478 0 0,051
8 0,109 0,582 0,582 0,633 0 0,154
9 0,098 0,680 0,680 0,689 0 0,056
10 0,035 0,715 0,715 0,738 0 0,049
11 0,008 0,723 0,738 0,739 1 0,001
12 0,048 0,772 0,772 0,775 0 0,036
13 0,130 0,902 0,902 0,902 0 0,128
14 0,026 0,928 0,928 1,104 0 0,202
15 0,260 1,188 1,188 1,215 0 0,112
16 0,048 1,236 1,236 1,237 0 0,022
17 0,009 1,245 1,245 1,341 0 0,104
18 0,018 1,263 1,341 1,369 1 0,028
19 0,026 1,288 1,369 1,399 2 0,030
Resumo dos Indicadores por SF

SF T N E[ic] E[tsf] E[nf] E[is] DP[ic] DP[tsf] DP[nf] DP[is] U
0 0,838 20 0,037 0,056 1,200 0,042 0,046 0,043 1,288 0,040 0,733
1 2,318 40 0,056 0,030 0,325 0,058 0,057 0,029 0,608 0,060 0,405
2 1,814 30 0,060 0,029 0,267 0,060 0,056 0,028 0,512 0,062 0,407
3 1,399 20 0,064 0,039 0,300 0,070 0,072 0,048 0,557 0,063 0,421
Legenda
l = taxa de chegada de pacotes na Fila

m = taxa de servico do Servidor
N = numero de pacotes simulados
T = duracao da simulacao
p = ordem dos pacotes
ic = intervalo entre chegadas de pacotes na Fila

cpf = tempo de chegada de pacote na Fila
eps = tempo de chegada de pacote no Servidor
sps = tempo de saida de pacote do Servidor
tsf = tempo total no Sistema de Fila
nf = comprimento da Fila
is = intervalo entre saidas de pacotes do Servidor
E (x) = media aritmetica de x
DP(x) = desvio padrao de x
U = utilizacao do Servidor
9.1 Sistema Cliente/Servidor Web em uma Camada Física
Um Sistema Cliente/Sevidor Web em uma camada física está ilustrada na Figura 9.1, com 3
SF, numeradas de 0 a 2, SF0, SF1 e SF2. A arquitetura desta rede está mostrada na Figura
9.2. É uma rede aberta com os parâmetros:
• os SF deste sistema são M/M/1

• sequência dos pacotes: 0 → 1, 1 → 2, 2 →1 e 1→ 0, r = [ 0, 1, 2, 1, 0 ]
• l
• m = [ m0, m1, m2 ]
Figura 9.1 Sistema Cliente/Servidor Web em uma camada física composta por um Firewall (F),
um Switch (S) e um Servidor Swab (Web, Aplicação e Banco de Dados).
Figura 9.2 A arquitetura do Sistema Cliente/Servidor Web da Figura 9.1.
Em resumo, os parâmetros da RSF da Figura 9.10, para simulação de 5000 pacotes são: r = [
0, 1, 2, 1, 0 ], N = 5000, l, m = [m0, m1, m2]. Os valores de l e m devem ser fornecidos pelo
usuário.
Exemplo 9.1 Considere a rede abaixo com demanda de 5 milhões de pacotes por hora, considere pacotes de 2
MB.
Figura 9.3 Sistema Cliente/Servidor Web do Exemplo 9.2.

Componente n Modelo Vazão
F 0 Sophos XG 21024 29 Gbps
S 1 US-16-150W25 36 Gbps
Swad 2 HPE ProLiant ML110 – E5-2620v426 8,0 GT/s
São 3 SF com r = [0, 1, 2, 1, 0]. Com uma demanda de 5 milhões de pacotes por hora, tem-se l = 5E6/3600 =
1388,8.
Cálculo de m = [m0, m1, m2] para pacotes de 2 MB:
9 b× pacote 9 pacote×b
m0=29 Gbps=29×10 =29×10 =1812,5 pps
s× pacote 2×106 ×8 b s
b× pacote pacote×b
m1=36 Gbps=36×109 =36×109 =2250 pps
s× pacote 2×10 6×8 b s
9 B× pacote 9 pacote×B
m2=8 GBps=8×10 =8×10 =4000 pps
s×pacote 2×106×B s
Logo m = [1812.5, 2250, 4000].
Os parâmetros desta RSF, para uma simulação de 5000 pacotes são:
r = [0, 1, 2, 1, 0], N = 5000, l = 1388.8 e m = [1812.5, 2250, 4000].
Resumo dos Indicadores por SF obtidos pelo RSF.MM1.cpp:
SF T N E[tsf] E[nf] U
0 7,18 10000 0 3,63 0,78
1 7,08 10000 0 2,53 0,62
2 3,38 5000 0 0,68 0,38
Os resultados da simulação que os equipamentos estão adequados para o projeto, com certa ociosidade do
servidor (Swab), podendo ser substituído por outro de vazão um pouco menor.
9.2 Sistema Cliente/Servidor Web em duas Camadas Físicas
Um Sistema Cliente/Sevidor Web em duas camadas físicas é ilustrada na Figura 9.4, com 4
SF, numeradas de 0 a 3, SF0, SF1, SF2 e SF3. A arquitetura desta rede está mostrada na
Figura 9.5. É uma rede com os parâmetros:

• sequência dos pacotes: 0 → 1, 1 → 2, 2 → 1, 1 → 3, 3 → 1, 1 → 2, 2 → 1, 1 → 0, r = [ 0, 1, 2, 1, 3, 1, 2, 1,
0]
• l
• m = [ m0, m1, m2, m3 ]
24 https://www.sophos.com/en-us/medialibrary/PDFs/factsheets/sophos-xg-series-appliances-brna.pdf
25 Fonte: https://dl.ubnt.com/datasheets/unifi/UniFi_PoE_Switch.pdf
26 Fonte: https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na-c04617738
Figura 9.4 Sistema Cliente/Servidor Web em duas camadas físicas compostas por um Firewall
(F), um Switch (S), um Servidor Web (Sw) e um Servidor Sab (Aplicação e Banco de Dados).
Em resumo, os parâmetros da RSF da Figura 9.12, para simulação de 5000 pacotes são: r = [
0, 1, 2, 1, 3, 1, 2, 1, 0 ], N = 5000, l, m = [m0, m1, m2, m3]. Os valores de l e m devem ser
fornecidos pelo usuário.
MB.
Figura 9.6 Sistema Cliente/Servidor Web do Exemplo 9.3.

S 1 US-16-150W28 36 Gbps
Sw 2 Apache HTTP Server 2.429 7500 req/s
Sad 3 HPE ProLiant ML110 – E5-2620v430 8,0 GT/s
São 3 SF com r = [0, 1, 2, 1, 3, 1, 2, 1, 0]. Com uma demanda de 5 milhões de pacotes por hora, tem-se l =
5E6/3600 = 1388,8.
O Servidor Web Apache HTTP Server 2.4 deve ser instalado em um Hardware com CPU de 16 núcleos, cada
núcleo processando 108 req/s31.
Logo m = [1812.5, 2250, 7500, 4000].
27 Fonte: https://www.sophos.com/en-us/medialibrary/PDFs/factsheets/sophos-xg-series-appliances-brna.pdf
29 Fonte: https://documentation.commvault.com/commvault/v11/article?p=1662.htm
31 Fonte: https://serverguy.com/comparison/apache-vs-nginx/
r = [0, 1, 2, 1, 3, 1, 2, 1, 0], N = 5000, l = 1388.8 e m = [1812.5, 2250, 7500, 4000].

0 7,33 10000 0 3,02 0,76
1 14,62 20000 0 3,78 0,61
2 7,08 10000 0 0,25 0,19
3 3,23 5000 0 0,66 0,38
Os resultados da simulação que os equipamentos estão adequados para o projeto, com certa ociosidade dos
servidores Sw e Sab.
9.3 Sistema Cliente/Servidor Web em três Camadas Físicas
Um Sistema Cliente/Servidor Web em três camadas físicas é ilustrada na Figura 9.7, com 5
SF, numeradas de 0 a 4, SF0, SF1, SF2, SF3 e SF4. A arquitetura desta rede está mostrada na
Figura 9.8. É uma rede com os parâmetros:

• sequência dos pacotes:
• 0 → 1, 1 → 2, 2 → 1, 1 → 3, 3 → 1, 1 → 4, 4 → 1, 1 → 3, 3 → 1, 1 → 2, 2 → 1, 1 → 0, r = [ 0, 1, 2, 1, 3, 1, 4, 1,
3, 1, 2, 1, 0 ]
• l
• m = [ m0, m1, m2, m3, m4 ]
Figura 9.7 Sistema Cliente/Servidor Web em três camadas físicas compostas por um Firewall
(F), um Switch (S), um Servidor Web (Sw), um Servidor de Aplicação (Sa) e um Servidor de
Banco de Dados (Sd).

Em resumo, os parâmetros da RSF da Figura 9.9, para simulação de 5000 pacotes são: r =
[ 0, 1, 2, 1, 3, 1, 4, 1, 3, 1, 2, 1, 0 ], N = 5000, l, m = [m0, m1, m2, m3, m4]. Os valores de l
e m devem ser fornecidos pelo usuário.
MB.
Figura 9.9 Sistema Cliente/Servidor Web de três camadas.

S 1 US-16-150W33 36 Gbps
Sw 2 Apache HTTP Server 2.434 7500 req/s
Sa 3 HPE ProLiant ML110 – E5-2620v435 8,0 GT/s
Sd 4 MariaDB 10.5.536 20 Ktps
https://mariadb.com/resources/blog/benchmark-mariadb-vs-mysql-on-commodity-cloud-hardware/
São 3 SF com r = [ 0, 1, 2, 1, 3, 1, 4, 1, 3, 1, 2, 1, 0 ]. Com uma demanda de 5 milhões de pacotes por hora,

tem-se l = 5E6/3600 = 1388,8.
O Servidor Web Apache HTTP Server 2.4 deve ser instalado em um Hardware com CPU de 16 núcleos, cada
núcleo processando 108 req/s37.
Logo m = [1812.5, 2250, 7500, 4000, 20000].
r = [ 0, 1, 2, 1, 3, 1, 4, 1, 3, 1, 2, 1, 0 ]], N = 5000, l = 1388.8 e m = [1812.5, 2250, 7500, 4000, 20000].

0 7,09 10000 0 3,24 0,76
1 17,81 25000 0 4,92 0,63
2 6,9 10000 0 0,27 0,19
3 3,18 5000 0 0,75 0,39
4 3,18 5000 0 0,09 0,08
Os resultados da simulação que os equipamentos estão adequados para o projeto, com certa ociosidade dos
servidores Sw, Sa e Sb.
Exemplo 9.4 Considere a rede abaixo com demanda de 5 milhões de pacotes por hora, considere pacotes de
200 KB.
32 Fonte: https://www.sophos.com/en-us/medialibrary/PDFs/factsheets/sophos-xg-series-appliances-brna.pdf
34 Fonte: https://documentation.commvault.com/commvault/v11/article?p=1662.htm
36 Fonte: https://mariadb.com/resources/blog/benchmark-mariadb-vs-mysql-on-commodity-cloud-hardware/
37 Fonte: https://serverguy.com/comparison/apache-vs-nginx/
Figura 9.10 Sistema Cliente/Servidor Web da Figura 9.9.

Componente n Modelo Desempenho (ts)
S 0 Cisco Catalyst 2960-CX 12 Gbps
Sw 1 Apache 2.4.1 108 req/s
Sad 2 MySQL 5.7 25 KTps
São 3 SF com r = [0, 1, 0, 2, 0, 1, 0]. Com uma demanda de 5 milhões de pacotes por hora, tem-se l =
5E6/3600 = 1388,89 pacotes por segundo ou l = 1389 pps.
Cálculo de ts0 para o pacote de 200 KB:
b×pacote pacote×b
m0=12 Gbps=12×10 9 =12×109 =7324 pacotes/ s
s× pacote 200 x 1024×8 b s
Logo m = [7324, 108, 25000].
r = [0, 1, 0, 2, 0, 1, 0], N = 5000, l = 1389 e m = [7324, 108, 25000].
9.4 Simulação de Sistemas de Hardware
A simulação sistema de hardware mostrado na Figura 9.11 é complexa e extrapola o nível

deste texto mas pode-se simular partes do mesmo e avaliar seu comportamento. Tomando
uma parte desta arquitetura, como mostrado na Figura 9.12. (Sun Microsystems, 2016).
Figura 9.11 Diagrama de blocos de parte do Sun Fire X4150 (Sun Microsystems, 2016).
Uma alternativa simples é considerar que dados chegam da memória por meio da ponte
norte (MCH) e são processados na CPU. Neste caso, pode-se considerar a MCH como a Fila e
a CPU como o Servidor, Figura 9.12, tem-se então uma rede aberta com os parâmetros:
• o SF é M/M/1
• l
• m = [m0 ]
Figura 9.12 Modelo de um Sistema de Fila da Figura 9.11.

9.5 Revisão
9.6 Exercícios
1. Simule os exemplos deste capítulo com o software RSF.MM1.cpp e calcule:
a) o tempo de simulação
b) os maiores valores de nf de cada componente
2. Simule os exemplos deste capítulo com o software RSF.MM1 e, considerando os valores de ts de maior
desempenho, calcule:
a) o tempo de simulação
b) os maiores valores de nf de cada componente
3. Compare os resultados dos exercícios 1 e 2.

10 GERAÇÃO DE NÚMEROS ALEATÓRIOS
Desde que, em 1859, Darwin e Maxwell introduziram a incerteza, a aleatoriedade e o acaso

como elementos explicativos nas ciências, esses agentes imprevisíveis revelaram-se
atuantes em todos os domínios da Natureza, da vida e invadiu as ciências.
Uma maneira de usar esta propriedade dos sistemas é fazer uso de números aleatórios. Em
estatística, um número aleatório é um número que pertence a uma série numérica e que não
pode ser previsto a partir dos seus membros anteriores (Jain,1991).
Gerador de Números Pseudo-Aleatórios (PRNG - PseudoRandom Number Generator), também

conhecido como gerador de bits aleatórios determinísticos (DRBG - Deterministic Random Bit
Generator ), são algoritmos para gerar sequências de números cujas propriedades se
aproximam das propriedades das sequências de números aleatórios. A sequência gerada por
um Gerador de Números Pseudo-Aleatório (GNPA) – doravante GNA - não é verdadeiramente
aleatória, porque é completamente determinada por um valor inicial, chamado de semente
do gerador.
A abordagem preferida para a geração de números aleatórios em computadores envolve a

utilização de fórmulas de recorrência que podem ser implementadas de forma simples e
rápida. Os elementos de uma série de números pseudoaleatórios 38, para aplicação em
simulações, quer sejam bits ou números, devem ter as propriedades:
• uniformemente distribuídos
• estatisticamente independente
• não repetição para um comprimento desejado
• reprodutível
• rápida obtenção de modo a poupar recursos computacionais para as simulações em si
Os primeiros GNAs desenvolvidos foram os Geradores Congruentes Lineares (GCL) proposto

por D. H. Lehmer em 1949. Uma lista completa dos GNAs pode ser obtida pesquisando
overbete “List of random number generators” na Wikipedia.
10.1 Geradores Congruentes Lineares (GCL)
A expressão geral do Gerador Congruente Linear (GCL) é x n = f(xn-1). O GCL expressa pela
Equação 10.1 (Hull & Dobell, 1962) é uma relação recursiva constituída por três valores
38A denominação número aleatório neste texto refere-se, em geral, a número pseudoaleatório. Algoritmos geram apenas
números pseudoaleatórios. O sítio www.random.org trata deste assunto extensivamente.
constantes ( a, c, m ∊ ℕ; a – constante multiplicadora, c - incremento e m - módulo) e a

semente x1.
x i =(a xi−1 +c) mod m 10.1
A partir de x1 são calculados sucessivamente os valores de x2, x3, x4, ..., xm.
É necessário que x1 ≠ x2 ≠ x3 ≠ … ≠ xm, ou seja, não tenha repetição na sequência gerada.

Entretanto, a existência de ciclos é comum nestas sequências.
Os parâmetros a, c e m do GCL afetam a média, a variância e a duração do ciclo das

sequências (sequência sem repetição). Para produzir séries de números aleatórios com
período máximo, ciclo de tamanho igual a m-1, deve-se selecionar os valores de a, c e m
conforme estabelece o Teorema de Hull-Dobell (Hull & Dobell, 1962), a saber:
Teorema de Hull-Dobell: O método congruente linear tem período m-1 se, e somente se,
as seguintes três condições são válidas (Hull & Dobell, 1962):
1. c e m são primos entre si, mdc(c,m) = 1
2. (a-1) é múltiplo de q, para todo fator primo q de m
3. se m é múltiplo de 4 então (a-1) é múltiplo de 4
Buscando produzir séries de números aleatórios com período máximo, Bandyopadhyay e

Bhattacharya (2014) estabelece outros critérios para os parâmetros a, c e m, descritos a
seguir:
1. se m = 2b e c ≠ 0 então o comprimento máximo do ciclo será igual a m para c e m primos entre si e

também a e m primos entre si com a = 1+4k, k inteiro.
2. se m = 2b e c = 0 então o comprimento máximo do ciclo será igual a 2 b-2 com a = 3+8k ou a = 5+8k, k
inteiro.
3. se m é um número primo e c = 0 então o comprimento máximo do ciclo será igual a m-1 com a k-1
divisível por m, onde k = m–1.
Exemplo 10.1 A série gerada a partir de m = 231-1, a = 75 e c = 0 tem um ciclo igual 2 31-1, aproximadamente
uma sequência de 2,1×109 números sem repetição, suficientemente grande para simulações de Redes de
Sistemas de Fila39.
10.2 Aplicação do GCL
A aplicação imediata dos GCLs é a geração de distribuições uniformes contínuas, U(0,1). A

função un=xn/m, un ∊ [0,1) e U = {un}.
Exemplo 10.2 A sequência xi = 6xi-1 + 5 mod 11 tem período igual a 11. Para x 1 = 0, a sequência gerada é { 0,
5, 2, 6, 8, 9, 4, 7, 3, 1 }. Dividindo estes valores por 11, obtêm-se U = { 0,0000 0,4545 0,1818 0,5455 0,7273
0,8182 0,3636 0,6364 0,2727 0,0909 }.
Uma observação importante sobre este exemplo é que a função x n é determinística. Dada a semente, podemos
predizer, com certeza, os números da sequência. No entanto, os números são aleatórios no sentido de que eles
passariam por testes estatísticos para aleatoriedade.
Os exemplos abaixo discutem a estrutura das sequências geradas por um GCL, suas
conclusões se aplicam a qualquer GCL que atende o Teorema de Hull-Dobell.
39 Números Aleatórios tem aplicações em diversas áreas, como jogos e criptopgrafia, cada uma delas tem seus GNAs adequados aos seus
propósitos. O GCL atende amplamente a simulação dos Sistemas Computacionais aqui estudados.
Exemplo 10.3 A sequência xi = 5xi-1 + 3 mod 8 tem período igual a 8. Na Tabela 10.1 estão os números
aleatórios gerados por esta sequência para vários valores de x1.
Tabela 10.1 Números aleatórios gerados a partir de xi = 5xi-1 + 3 mod 8 para x1 = 0, 1, ..., 7 (semente)
x0 0 1 2 3 4 5 6 7
x1 3 0 5 2 7 4 1 6
x2 2 3 4 5 6 7 0 1
x3 5 2 7 4 1 6 3 0
x4 4 5 6 7 0 1 2 3
x5 7 4 1 6 3 0 5 2
x6 6 7 0 1 2 3 4 5
x7 1 6 3 0 5 2 7 4
Na Tabela 10.1, as sequências geradas são as colunas, a linha coluna correspondente a x 1 é a semente utilizada
para gerar a coluna de números aleatórios. A análise dos valores gerados apresentados na Tabela 10.1
permitem as seguintes conclusões:
• as sequências geradas têm os mesmos valores, são os números de 0 a 7, o que muda é a ordem destes
números em cada sequência (coluna) gerada40
• a semente x1 determina a ordem da sequência
• m determina a quantidade de valores gerados no ciclo
• o ciclo deste gerador é igual a 8 (m) e sua sequência é { x 0, x1, x2, x3, x4, x5, x6, x, x7 }
• a soma do ciclo gerado é igual a 28, generalizando, m(m-1)/2
Nota: denomina-se GCL misto se c = 0 e GCL multiplicativo se c ≠ 0.

Exemplo 10.4 A sequência xi = 5xi-1 + 3 mod 8 tem período igual a 8. Na Tabela 10.2 estão os números
aleatórios gerados por esta sequência para vários valores de x1. Em linhas e colunas duplicadas.
Tabela 10.2 Números aleatórios gerados a partir de xi = 5xi-1 + 3 mod 8 para x1 = 0, 1, ..., 7 (semente)
x1 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
x2 3 0 5 2 7 4 1 6 3 0 5 2 7 4 1 6
x3 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1
x4 5 2 7 4 1 6 3 0 5 2 7 4 1 6 3 0
x5 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3
x6 7 4 1 6 3 0 5 2 7 4 1 6 3 0 5 2
x7 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5
x8 1 6 3 0 5 2 7 4 1 6 3 0 5 2 7 4
x9 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
x10 3 0 5 2 7 4 1 6 3 0 5 2 7 4 1 6
x11 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1
x12 5 2 7 4 1 6 3 0 5 2 7 4 1 6 3 0
x13 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3
x14 7 4 1 6 3 0 5 2 7 4 1 6 3 0 5 2
x15 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5
40 Um GCL gera uma única série aleatória e, ao variar a semente, pode-se acessar diferentes sequências desta série.
x16 1 6 3 0 5 2 7 4 1 6 3 0 5 2 7 4
Na Tabela 10.2, as sequências geradas são as colunas, a linha coluna correspondente a x 1 é a semente utilizada
para gerar a coluna de números aleatórios. A análise dos valores gerados apresentados na Tabela 10.2
permitem as seguintes conclusões:
• as sequências geradas têm os mesmos valores, são os números de 0 a 7, o que muda é a ordem destes
números em cada sequência (coluna) gerada
• a semente x0 determina a ordem da sequência
• m determina a quantidade de valores gerados no ciclo,
• o ciclo deste gerador é igual a 8 (m) e sua sequência é { x 1, x2, x3, ..., x8 }
• a partir de x9 a sequência é reiniciada, e o novo ciclo é igual ao ciclo anterior, ou seja, x 9 = x1, x10 = x2,
…, x15 = x7, x16 = x1, e assim por diante
• para x1 = x9 = x17 = … = xkm+1, k = 1, 2, 3, ...
• para xkm+1, k = 1, 2, 3, …, a sequência gerada é reiniciada
10.3 Sementes para o GCL
Como foi destacado, a semente x0 é o primeiro valor de uma sequência dos GCLs e, para
gerar as diferentes sequências do mesmo GCL, bastar fazer variar suas sementes. Logo, a
seleção adequada da semente se reveste de grande importância.
A técnica de associar o valor da semente ao momento atual é capaz de gerar as diferentes

sequências de um GCL. Esta técnica, que usa a medição do tempo, gera sementes
adequadas para os GNA, uma vez que o tempo é uma grandeza que cresce continuamente.
A linguagem C, por exemplo, possui a função time(nullptr) que obtém o número de segundos
transcorridos desde 01/01/1970 00:00:00.
10.4 GCL de uso geral
Na Tabela 10.3 estão algumas linguagens de programação e seus GNA GCL. Estes GCL
possuem período máximo igual a m.
Pode-se destacar nesta tabela o GCC, utilizado na linguagem de programação C/C++ 32 b,

ele é um GCL misto com a recorrência dada pela fórmula: x n+1 = (1103515245 xn+12345)
mod 231, que é capaz de produzir uma sequência de números inteiros no conjunto { 0, 1, 2, 3,
..., 231= 2147483648 ≈ 2,1×109}.
O GCL MMIX de 64 b com um ciclo de 1,8x10 19 e também o GCL Posix de 48 b com um ciclo
de 2,8×1014.
Tabela 10.3 Geradores de números aleatórios adequados à simulação de RSF

Fonte m a c
Borland C++ 232 22695477 1
GCC 231 1103515245 12345
Posix 248 25214903917 11
Microsoft Visual Basic 224 1140671485 12820163
Microsoft Visual C++ 232 214013 2531011
MMIX 264 6364136223846793005 1442695040888963407
Numerical Recipes 232 1664525 1013904223
RANDU 231 65539 0

VAX 231 69069 1
10.5 Números Aleatórios do GNU C
A linguagem C (GNU GCC e G++) possui duas funções e uma constante para gerar números
aleatórios com seu GCL (Tabela 10.3), a saber:
Tabela 10.4 As funções, a constante e as bibliotecas da linguagem C para gerar números

aleatórios
Recurso Descrição
RAND_MAX constante inteira definida no arquivo stdlib.h
void srand(unsigned) atribui semente ao CGL, em geral srand(time(0))
int rand(void) retorna um número pseudoaleatório com valor em [0, RAND_MAX]
stdlib.h, time.h bibliotecas da linguagem C
O Algoritmo 10.1 gera números pseudoaleatórios com valor em [0,RAND_MAX] tendo como
semente time(0) - número de segundos decorridos desde 01/01/1970 00:00:00 UTC.
Algoritmo 10.1 Programa em C para gerar números pseudoaleatórios com valor em

[0,RAND_MAX]
#include <stdlib.h>
#include <time.h>
long gna( void ){
return rand();
}
int main( void ){
printf( " %d ", gna() );
return 0;
}
O Algoritmo 10.2 gera valores da distribuição uniforme U no intervalo (0,1) tendo como
semente time(0).
Algoritmo 10.2 Programa em C para gerar valores da distribuição uniforme no intervalo (0,1)
#include <stdlib.h>
#include <time.h>
double u( void ){
return (rand()+1.0)/(RAND_MAX+2.0); // intervalo (0,1)
}
int main( void ){
printf( " %f ", u() );
return 0;
}
Na biblioteca GNU Scientific Library (https://www.gnu.org/software/gsl/doc/html/) pode-se

encontrar vários GCL.
Para gerar valores da distribuição uniforme U no intervalo [0,1] deve ser usada a Equação 10.2.
rand ( )
∈[0,1] 10.2
RAND MAX
Para gerar valores de U no intervalo (0,1) deve ser usada a Equação 10.3.
rand ( )+1
∈(0,1) 10.3
RAND MAX +2
Para gerar valores de U no intervalo [a,b] deve ser usada a Equação 10.4 para u ∊ [0,1].
a+(b−a)u 10.4
Para gerar valores de U no intervalo (a,b) deve ser usada a Equação 10.5 para v ∊ (0,1).
a+(b−a) v 10.5
10.6 Composição de Geradores
A combinação de geradores resulta numa sequências de valores com melhores propriedades

estatísticas e com períodos mais longos em comparação com aqueles gerados a partir de um
único gerador. Um exemplo é o gerador Zn apresentado abaixo, que combina dois GCLs, An e
Bn:
A n =(a 0 A n−1 +a 1 A n−2 )mod m a
Bn =(b 0 B n−1 +b1 B n−2) mod m b 10.6
Z n=( A n + B n) mod m
Uma rica fonte de GNA é a “GNU Scientific Library”, seu manual está disponível em
https://www.gnu.org/software/gsl/doc/html/. O exemplo abaixo foi extraído deste documento.
Exemplo 10.5 zn é um outro gerador recursivo combinado de L’Ecuyer, ele combina dois geradores recursivos e
tem período igual a 2185 (4,9×1055):
z n=(x n − y n )mod m1
x n=(a1 x n−1 +a2 x n−2 +a3 x n−3 )mod m1
y n =(b 1 y n−1 +b 2 y n−2 +b 3 y n−3) mod m2
em que a1 = 0, a2 = 63308, a3 = −183326, b1 = 86098, b2 = 0, b3 = −539608, m1 = 2147483647 e m2 =
2145483479.
Fonte: GNU Scientific Library, Release 2.6. 2019 (https://www.gnu.org/software/gsl/doc/html/).
Exemplo 10.6 O gerador recursivo combinado L’Ecuyer's, referido como MRG32k3a (L’Ecuyer, 2020), combina
dois geradores recursivos e tem período igual a 2 191 (3,1×1057), suficientemente longo para a maioria das
simulações senão para todas elas (L’Ecuyer's, 2007):
xi = ( a1 xi-1 + a2 xi-2 + a3 xi-3 ) mod m1
yi = ( b1 yi-1 + b2 yi-2 + b3 yi-3 ) mod m2
zi = ( xi-yi ) mod m1
ui = zi/m1
em que:
a1 = 0, a2 = 1403580, a3 = 810728, m1 = 232-209,
b1 = 527612, b2 = 0, b3 = 1370589 e m2 = 232-22853,
zi, i = 1, 2, ... é a sequência de números pseudoaleatórios,
ui, i = 1, 2, ... é a distribuição uniforme desejada
Algoritmo 10.3 Código em C do gerador recursivo combinado MRG32k3a, adaptado de

(L’Ecuyer, 2020)
// MRG32k3a: 32-bits Random number generator U(0,1)
// Author : Pierre L'Ecuyer,
// Source : Good Parameter Sets for Combined Multiple Recursive Random Number Generators,
// Shorter version in Operations Research, 47, 1 (1999), 159–164.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define norm 2.328306549295728e-10
#define m1 4294967087.0
#define m2 4294944443.0
#define a12 1403580.0
#define a13n 810728.0
#define a21 527612.0
#define a23n 1370589.0
// The seeds for s10, s11, s12 must be integers in [0, m1-1] and not all 0.
// The seeds for s20, s21, s22 must be integers in [0, m2-1] and not all 0.
long s10, s11, s12, s20, s21, s22;
int gna( void ){
return rand(); // intervao [0,RAND_MAX]
}
double MRG32k3a(void){
long k;
double p1, p2;
p1 = a12 * s11 - a13n * s10; // Component 1
k = p1 / m1;
p1 -= k * m1;
if( p1 < 0.0 ) p1 += m1;
s10 = s11;
s11 = s12;
s12 = p1;
p2 = a21 * s22 - a23n * s20; // Component 2
k = p2 / m2;
p2 -= k * m2;
if( p2 < 0.0 ) p2 += m2;
s20 = s21;
s21 = s22;
s22 = p2;
printf( "%11ld %11ld %11ld :: ", s10, s11, s12);
printf( "%11ld %11ld %11ld >> ", s20, s21, s22);
return norm*( p1 <= p2 ? p1-p2+m1 : p1-p2 ); // Combination
}
int main( void ){
int i;
srand(time(0));
s10 = gna(), s11 = gna(), s12 = gna(),
s20 = gna(), s21 = gna(), s22 = gna();
for( i = 0; i < 20; i++ )
printf( "%.22lf\n", MRG32k3a() );
return 0;
}
10.7 Geradores Tausworthe
Os geradores Tausworthe operam diretamente sobre bits. Uma sequência de dígitos binários
é definida pela recorrência bi = (c1bi-1 + c2bi-2 + ··· + cqbi-q) mod 2, onde c1, ..., cq são
constantes binárias.
Neste caso, um ciclo é definido como uma sequência de valores binários que se repetem
continuamente. Portanto, como os q bits anteriores são utilizados, o período pode chegar a 2 q
- 1. De modo geral, os geradores Tausworthe são da forma b i = (bi-r+ bi-q) mod 2 sendo r, q ∈
N e 0 < r < q.
10.8 Outros Geradores
O Gerador Mersenne Twister (MT) foi desenvolvido por Makoto Matsumoto e Takuji Nishimura.
Seu ciclo é extremamente longo, com período de 2 19937-1 (aproximadamente 1013819), com
sequência iid. Seu código em C está disponível no arquivo mt19937.c (Mersenne Twister,
2011). Este gerador já está disponível em C++ na sua biblioteca random.
A API Math.random(), escrita em JavaScript, utiliza o GNA Xoroshiro128+ gera números no

intevalor [0,1), este GNA se baseia no Gerador MT.
10.9 Classe clGNA
A classe clGNA escrita em Javascript está descrita no Algoritmo 10.4. Nesta classe a semente
(x0) é obtida do tempo do navegador, dado em milissegundos desde 01/01/1970. Por
exemplo, para a data 28/05/2020 às 10h00min a semente é igual a 1590660000.
Nesta classe, o valor de m é 231-1, mas pode-se adaptar a classe para outros valores de m. O
valor de x0 é corrigido se x0 > m e se x 0 < 0. A função setX0 é executada quando se instância
um objeto da classe. As funções gna, gna1, gna2, ..., gna7, geram números aleatórios no
intervalo [0,m-1].
Algoritmo 10.4 Classe clGNA em Javascript para os GCL’s da Tabela 10.3

function clGNA(){
let x, m0, m1, m2, m3;
this.ANSI = function(){ x = ( 1103515245*x+ 12345)%m0; return (x/m0); }
this.Apple = function(){ x = ( 16807*x )%m1; return (x/m1); }
this.BorC = function(){ x = ( 22695477*x+ 1)%m2; return (x/m2); }
this.BorD = function(){ x = ( 134775813*x+ 1)%m2; return (x/m2); }
this.C11 = function(){ x = ( 48271*x )%m1; return (x/m1); }
this.cc65 = function(){ x = ( 16843009*x+ 826366247)%m2; return (x/m2); }
this.GCC = function(){ x = ( 1103515245*x+ 12345)%m0; return (x/m0); }
this.glibc = function(){ x = ( 1103515245*x+ 12345)%m0; return (x/m0); }
this.Java = function(){ x = (25214903917*x+ 11)%m3; return (x/m3); }
this.MVC = function(){ x = ( 214013*x+ 2531011)%m2; return (x/m2); }
this.NR = function(){ x = ( 1664525*x+1013904223)%m2; return (x/m2); }
this.Posix = function(){ x = (25214903917*x+ 11)%m3; return (x/m3); }
this.Randu = function(){ x = ( 65539*x )%m0; return (x/m0); }
this.Rtl = function(){ x = ( 2147483629*x+2147483587)%m1; return (x/m1); }
this.Vax = function(){ x = ( 69069*x+ 1)%m0; return (x/m0); }
this.VMS = function(){ x = ( 69069*x+ 1)%m2; return (x/m2); }
this.Javascript = function(){ return Math.random(); }
this.setX0 = function(){
x = (new Date()).getTime();
m0 = 2147483648, //Math.pow(2,31)
m1 = 2147483647, //Math.pow(2,31)-1
m2 = 4294967296, //Math.pow(2,32)
m3 = 281474976710656; //Math.pow(2,48)
if( x > m1 ) x = x % m1;
}
this.setX0();
}
O Exemplo 10.8 é um programa em C++ para gerar números aleatórios Apple CarbonLib,
conforme a descrito na Tabela 10.3. Os demais GCL desta tabela podem ter programas
semelhantes ao exemplo abaixo.
Exemplo 10.7 Programa em C++ para gerar números aleatórios Apple CarbonLib.
O GNA Apple CarbonLib tem m = 2 31-1, a = 16807 e c = 0, a função gnacl abaixo gera dados deste GNA com
semente obtida do tempo do sistema.
O software abaixo gera 10 números aleatórios Apple CarbonLib.
#include <iostream>
#include <cmath>
#include <ctime>
long gnacl( void ){

static long x = time(NULL),

m = pow(2,31)-1;
x = (16807*x)%m;
return x;
}
int main( void ){
for( int i = 0; i < 10; i++ )
cout << gnacl() << endl;
return 0;
}
10.10 Teste Empíricos de GNA
É uma boa prática verificar estatisticamente os valores de um gerador de números

pseudoaleatório antes de usá-lo. O comportamento estatístico de um gerador de números
aleatórios pode ser influenciado pela sua implementação em uma linguagem de
programação bem como pelo hardware utilizado. Existe uma grande variedade de testes para
sequências de números aleatórios, como os seguintes testes estatísticos:
• Teste de frequência
• Teste de serial
• Teste de autocorrelação
• Teste runs
• Teste de Chi-Quadrado
Também existe muita controvérsia sobre quais são os melhores, se testes teóricos são mais
definitivos que os empíricos. Se a amostra utilizada em um teste empírico for muito pequena,
o resultado pode corresponder apenas a um pequeno fragmento do ciclo. Por outro lado, um
teste que leva em conta um ciclo inteiro pode não ser compatível com fragmentos deste
mesmo ciclo.
Nenhuma quantidade de testes pode determinar que um gerador é o melhor em todos os

casos. Portanto, a recomendação é que os testes sejam consistentes com o uso que será
dado ao gerador. Se os números serão utilizados aos pares, por exemplo, deve-se examinar o
comportamento de pares e, neste caso, talvez com um teste serial seja o mais apropriado.
Assim, deve-se escolher com cuidado o teste do gerador se a simulação é onerosa, requer
alta precisão ou é um componente crítico de um estudo.
Muitos testes estatísticos úteis podem ser encontradas em NIST (2010). Os sítios a seguir
possuem suítes para testar sequências de números aleatórios:
• Dieharder: A Random Number Test Suite http://www.phy.duke.edu/~rgb/General/dieharder.php

• The Marsaglia Random Number CDROM including the Diehard Battery of Tests of Randomness
http://i.cs.hku.hk/~diehard/cdrom/
• TestU01: A C Library for Empirical Testing of Random Number Generators
http://www.iro.umontreal.ca/~lecuyer/myftp/papers/testu01.pdf
10.10.1 Testes Empíricos
O gráfico dos pares (x i,xi+1) de números aleatórios permite avaliar a independência do

gerador de números aleatórios. Quando números da sequência são independentes eles ficam
dispersos aleatoriamente sem tendência, caso contrário estão próximos de uma reta. Pode-se
notar na Figura 10.1 a falta de tendência na distribuição dos 500 pontos gerados,
evidenciando graficamente a independência dos dados amostrados.
Figura 10.1 Gráfico de dispersão para avaliar graficamente a independência dos números
aleatórios.
A Figura 10.1 foi gerada pelo Algoritmo 10.5.
Algoritmo 10.5 O gráfico dos pares de números aleatórios em Javascript.

<!doctype html>
<html>
<title>Dispersao de Numeros Aleatorios</title>
<head>
<script>
function Plot(){
var cnv = document.getElementById("dispersao"),
ctx = cnv.getContext("2d"),
X = parseInt(cnv.getAttribute("width" )),
Y = parseInt(cnv.getAttribute("height")),
d = 8,
N = 500,
x = [1];
ctx.fillStyle = "rgb(10,70,200)";
for( var i = 1; i < N; i++ ){
x[i] = Math.random();
ctx.fillRect(x[i-1]*(X-d),x[i]*(Y-d),d,d);
}
}
window.onload = Plot;
</script>
</head>
<body>
Grafico de Dispersao de Numeros Aleatorios<br><br>
<canvas id="dispersao" width="300" height="300"></canvas><br>
</body></html>
A Figura 10.2 é um gráfico de barra que é útil para avaliar graficamente a independência e a
distribuição dos números aleatórios gerados. As alturas das barras exibem poucas diferenças
indicando que os números gerados estão bem distribuídos.
Figura 10.2 Gráficos de barra para avaliar a independência e a distribuição de números

aleatórios.
A Figura 10.2 foi gerada pelo Algoritmo 10.6 escrito em Javascript, que faz uso da biblioteca
gráfica flot (www.flotcharts.org), utilizando as bibliotecas jquery.js e jquery.flot.js.
Algoritmo 10.6 Código Javascript para gerar gráficos de barra de números aleatórios
<!doctype html>
<html>
<title>Grafico de Barra de Numero Aleatorio</title>
<head>
<script src="jquery.js"> </script>
<script src="jquery.flot.js"></script>
<script>
function Plot(){
var q = 10,
n = 0,
d = new Array(q),
sum = new Array(q);
for( var i = 0; i < q; i++ )
sum[i] = 0;
var timer = setInterval(function(){
$(function(){
for( var i = 0; i < q; i++ ){
var r = Math.floor(Math.random()*q);
sum[r]+= 1;
d[i] = d.push([i+1,sum[r]]);
n++;
}
document.getElementsByName('valor')[0].value = n;
$.plot($("#graph"),[{data:d,bars:{ show:true,barWidth:0.3}}]);
});
},200);
}
window.onload = Plot;
</script>
</head>
<body>
<h3>Grafico de Barra de Gerador de Numero Aleatorio</h3>
<div id="graph" style="width: 400px; height: 400px;"></div>
<input type="text" value="0" name="valor" size="12">
</body></html>
10.11 Testes Teóricos

Os testes teóricos consistem em verificar se uma sequência de números aleatórios são

uniformemente distribuídos, o que pode ser feito pelo Teste Chi-Quadrado. Se são
estatisticamente independente, feito pela autocorrelação. Se não repetem para um
comprimento desejado, feito pelo Teorema de Hull-Dobel. Se são reprodutível, basta ser GCL.
E, por fim, se tem rápida obtenção, deve-se calcular o custo computacional do GNA.
GNA com Distribuição Uniforme
O Teste Chi-Quadrado (CQ) pode ser usado como teste de aderência de uma sequência de
números aleatórios à distribuição de probabilidade uniforme (DPU) com nível de significância
α.
Para verificar se a sequência X = { x1, x2, …, xn } se ajusta à DPU, o Teste CQ requer:
• segmentar X em k classes de mesmo tamanho

• calcular a frequência observada Oi de cada classe, i = 1, 2, ..., k
• calcular a frequência esperada Ei de cada classe, Ei = n/k (DPU), i = 1, 2, ..., k
k 2
(O i −E i )
• calcular a estatística D=∑ que tem distribuição χ2 com gl = k-1 graus de liberdade para
i=1 Ei
a DPU
• decidir: se D < χ2(1-α;gl) não se pode rejeitar a hipótese H 0 ao nível de significância α, caso contrário
rejeita-se a hipótese H0.
A distribuição χ2 permite obter o valor de χ2(1-α,gl) com nível significância α e gl graus de

liberdade (valor tabelado – unicaudal).
Exemplo 10.8 Foram gerados uma sequência com 140 números aleatórios, organizados em 7 classes, descritas
abaixo. Verifique se a sequência é uniformemente distribuída com 5% de significância.
Classe Frequência (Oi)

1 35
2 20
3 30
4 15
5 10
6 10
7 20
Hipóteses a serem testadas:
• H0: a sequência de números aleatórios é uniformemente distribuída

• Ha: a sequência de números aleatórios não é uniformemente distribuída
Tamanho da amostra: n = 140

Número de classes: k = 7
Cálculo de Ei = 140/7 = 20, i = 1, 2, ..., k
i Oi Ei
1 35 20
2 20 20
3 30 20
4 15 20
5 10 20
6 10 20
7 20 20
Cálculo de D = (35-20)2/20 +(20-20)2/20 + ... + (20-20)2/20 = 27,5
Regra de decisão: se, para α fixado, obtém-se D > χ 2(1-α;gl) então rejeita-se a hipótese H0, caso contrário a
hipótese H0 não pode ser rejeitada.
Valor de χ2(0,95;6) = 12,59 (valor tabelado – unicaudal)
Neste caso, χ2(0,95;6) = 12,59 e D > χ2(0,95;6), isto é, 27,5 > 12,59. Rejeita-se H0.
Conclusão: a sequência de números aleatórios não é uniformemente distribuída segundo o Teste de CQ com
95% de confiança.
GNA Estatisticamente Independente
Para verificar se uma sequência de números aleatórios são estatisticamente independente,

pode-se usar a autocorrelação ρ(k) que informa o quanto o valor de uma variável aleatória é
capaz de influenciar seus vizinhos à distância k, k > 0. Como os valores de ρ(k) variam de -1
a 1, a ausência de correlação é indicada por 0, ou seja, os números aleatórios da sequência
analisada são estatisticamente independente.
Uma sequência com n números aleatórios têm autocorrelação ρ(k) dada pela Equação 10.7.
n−k
Cov( X i , X i +k ) E [( X i −μ)( X i+k −μ)]

∑ ( X i−μ)( X i+k−μ)
i=1
ρ(k )= 2
= 2
= n
10.7
σ σ
∑ ( X i−μ)
2
i=1
Exemplo 10.9 Verifique se os números aleatórios X = { 3, 2, 5, 4, 7, 6, 8 } são estatisticamente independente.
Para calcular ρ(1) são necessários calcular:
• tamanho da amostra: n = 7
• média amostral: m = (3+2+5+4+7+6+8)/7 = 35/7 = 5
• numerador: [(3-5)x(2-5)+(2-5)x(5-5)+(4-5)x(4-5)+(4-5)x(7-5)+(7-5)x(6-5)+(6-5)x(8-5)] = 9
• denominador: [(3-5)2+(2-5)2+(5-5)+(4-5)2+(7-5)2+(6-5)2+(8-5)2] = 28
• autocorrelação: ρ(1) = 9/28 = 0,32
Conclusão: X não é estatisticamente independente.
Custo Computacional de GNA
O custo computacional de um GNA é o tempo necessário para gerar um elemento de sua

sequência. Neste caso, basta dividir o tempo requerido para gerar uma sequência de
números aleatórios pelo tamanho da sequência gerada.
Algoritmo para testes teóricos

O Algoritmo 10.7, escrito em Javascript, ilustra alguns dos testes teóricos mais usuais:
autocorrelação, teste de CQ e custo computacional.
Este algoritmo permite fazer o Teste de CQ com e significância α = 1% e amostras

organizadas em 10 ou 20 classes, para isso basta usar adequadamente as constantes:
• Número de classes para o Teste CQ: CLASSE = 20 // ou CLASSE = 10
• Tamanho da amostra para o Teste CQ: NUMERO = 1000000
• Tamanho da amostra para o Custo Computacional: CUSTO = 9000000,
• Valor tabelado de χ2(0,99;9): X9 = 21.67, CQ(1-α=0,99,gl = 9) - quando CLASSE = 10
• Valor tabelado de χ2(0,99;19):X19 = 36.19; CQ(1-α=0,99,gl = 19) - quando CLASSE = 20
A função Calculate gera x[N] números aleatórios e os classifica em v[CLASSE] classes. A
função gna permite gerar números aleatórios utilizando a função Math.random(). A função
Autocorrelacao calcula a autocorrelação de x[N] com k = 1. A função CQ faz o teste de CQ de
v[CLASSE]. A função Custo estima o tempo médio para se gerar um milhão de números
aleatórios.
No Firefox 48.0 a autocorrelação obtida foi de 2.980e-2, indicando independência dos

números gerados; o Teste de CQ foi: “a distribuição do GNA é uniforme (16.37 < 36.19) com
99% de confiança”, indicando que a sequência de números aleatórios gerada é iid U(0,1); e o
custo unitário do GNA medido foi de 2.960e-6 s, suficientemente pequeno.
Algoritmo 10.7 Código Javascript para calcular a autocorrelação de números aleatórios

<!DOCTYPE>
<html>
<head>
<meta charset="UTF-8">
<meta content="Brauliro Goncalves Leal" name="author">
<style>
body { font-family: Arial; font-size: 25px; }
table{ font-family: Arial; font-size: 20px; }
</style>
<script src="clGNA.js"></script>
<script>
var CLASSE = 20, NUMERO = 1000000, CUSTO = 9000000,
X9 = 21.67, // CQ(1%, gl = 9 )
X19 = 36.19; // CQ(1%, gl = 19)
function Autocorrelacao( x ){
var k = 1, m = 0.0, num = 0.0, s2 = 0.0;
for( var n = 0; n < NUMERO; n++ )
m += x[n];
m /= NUMERO;
for( var n = 0; n < NUMERO; n++ )
s2 += (x[n]-m)*(x[n]-m);
s2 = s2/(NUMERO-1);
for( var n = 0; n < NUMERO-k; n++ )
num += (x[n]-m)*(x[n+k]-m);
return "autocorrelação = " + (num/s2/(NUMERO-k)).toFixed(5);
}
function CQ( fo ){
var D = 0.0, CQ;
for( var n = 0; n < CLASSE; n++ ){
var fe = 1.0/CLASSE;
D += Math.pow( fo[n] - fe, 2.0 )/fe;
}
if( D < X19 ) CQ = " CQ: Ho não pode ser rejeitada, a distribuição é uniforme ("
+ D.toFixed(5) + " < " + X19 + ") com 99% de confiança";
else CQ = "CQ: Ho é rejeitada (" + D.toFixed(5) + " >= " + X19
+ ") com 99% de confiança";
return CQ;
}
function Custo(){
var gna = new clGNA(),
inicio = (new Date()).getTime(),
fim;
for( var n = 0; n < CUSTO; n++ )
var a = gna.gna();
fim = (new Date()).getTime();
return "custo unitário = " + ((fim-inicio)/CUSTO).toExponential(4) + " s";
}
function prn(fo,v){
var str = "<br><table border='1'><tr><td>i<td>v[i]<td>fo[i]<td>fe[i]";
for( var i = 0; i < CLASSE; i++ )
str += "<tr><td>"
+ i + "<td>"
+ v[i] + "<td>"
+ fo[i].toFixed(4) + "<td>"
+ 1.0/CLASSE;
str += "</table>";
return str;
}
function Calcular(){
var gna = new clGNA(), x = [], v = [], fo = [], str = "";
v[i] = fo[i] = 0.0;
for( var n = 0; n < NUMERO; n++ ){
x[n] = gna.gna();
v[Math.floor(CLASSE*x[n])] += 1;
}
fo[i] = v[i]/NUMERO;
str += "<p> " + prn(fo,v)
+ "<p>1. " + Autocorrelacao(x)
+ "<p>2. " + CQ(fo)
+ "<p>3. " + Custo();
return str;
}
window.onload = function(){
texto.innerHTML = "Testes Teóricos para Geradores de Números Aleatórios<hr>"
+ Calcular()
+ "<p>Conclusão: GNA estatisticamente independentes (1),"
+ " uniformemente distribuído (2) e"
+ " de baixo custo computacional (3).";
}
</script>
</head>
<body>
<div id="texto"></div>
</body>
</html>
É importante que o GNA utilizado no processo de simulação seja igualmente distribuído

porque garante que, independente dos dados iniciais e de quem as façam ou quando as
façam, as simulações que o utilizarem apresentaram resultados similares. Esta é uma
conclusão de ordem operacional, que assegura confiabilidade à simulação enquanto técnica
e embasa seu uso e aplicações.
Devido à Lei dos Grandes Números, poucos dados gerados por um GNA são mal distribuídos.
Porém, ao gerar grandes quantidades de dados por meio de um GNA, pode-se observar que
tendem a serem igualmente distribuídos.
Daí surge uma pergunta, quantos pacotes devem ser simulados? Experimentalmente, pode-
se observar que a partir de 3.000 (três mil) valores gerados de um GNA já se obtém-se uma
boa uniformidade na distribuição dos dados, são razoavelmente uniformes. A partir daí já se
observa variações devido ao acaso, à aleatoriedade dos processos e dos sistemas,
construídos ou não pelo homem.
Esta não é ainda nossa resposta porque a simulação vai além do GNA, mas já é um bom
começo.
O Algoritmo 10.8 gera números aleatórios e os classifica em 10 (dez) decis, ele foi executado
para n iguais a 500, 1000, 2000, 3000, 4000, 5000 e 10000, estes resultados podem ser
vistos na Tabela 10.5. Quanto mais números são gerados melhor a distribuição entre os
decis.
Algoritmo 10.8 Código Javascript para gerar e exibir números aleatórios classificados em 10
decis.
<!doctype html>
<html>
<title>Classificação de Números Aleatórios</title>
<head>
<script>
var q = 10,
n = 0,
sum = new Array(q);
function Random(){
for( var i = 0; i < q; i++ )
sum[i] = 0;
setInterval(Vetor,5);
}
function Vetor(){
var r = Math.floor(Math.random()*q),
wnd = document.getElementById("txt"),
txt;
sum[r] = sum[r]+1;
n++;
txt = "<table border='1'><tr>";
for( var i = 0; i < q; i++ ){
txt += "<td>" + (sum[i]/n).toFixed(3);
}
txt += "</table>";
wnd.innerHTML = " numeros gerados = " + n + txt;
}
window.onload = Random;
</script>
<body><div id="txt"></div></body>
</html>
Tabela 10.5 Classes de números aleatórios utilizando o Algoritmo 10.8 para n iguais a 500,
1000, 2000, 3000, 4000, 5000 e 10000.
números gerados = 500
0.104 0.100 0.108 0.106 0.092 0.102 0.092 0.088 0.102 0.106

0.095 0.111 0.106 0.116 0.093 0.100 0.099 0.092 0.083 0.105

0.098 0.113 0.107 0.104 0.096 0.106 0.086 0.099 0.084 0.109

0.098 0.112 0.104 0.104 0.092 0.109 0.087 0.096 0.088 0.110

0.098 0.109 0.104 0.106 0.092 0.106 0.090 0.097 0.089 0.108

0.100 0.109 0.101 0.105 0.096 0.105 0.090 0.098 0.090 0.106

0.096 0.104 0.102 0.103 0.095 0.103 0.096 0.101 0.097 0.104
A Figura 10.3 apresenta a variação de ρ(1) de n valores GNA GCC do C++, para n de 500 a
10000. O valor de ρ(1) diminui com n e, para n > 500, as sequências geradas são
estatisticamente independentes pois ρ(1) < 0,02 – muito próximo de zero.
Figura 10.3 Variação de ρ(1) em função de n, em n é o tamanho de sequências de GNA GCC

do C++, cada valor de ρ(1) é a média de 10 repetições da mesma sequência de tamanho n.
10.12 Questões
1. Quais as diferenças entre número aleatório e número pseudoaleatório?

2. O que é ciclo de um GNA? Qual sua importância na simulação?
3. Como avaliar a qualidade de um GNA?
4. Discuta os GNA’s propostos por L’Ecuyer. Faça uma pesquisa na Internet sobre ele.
5. Qual é o período do GCL com m = 231, a = 314159269 e b = 453806245?
10.13 Exercícios
1. Verifique a correção das Equações 10.2 a 10.5 por meio de um programa em C.

2. Gerar 10.000 números usando a semente x 0 = 1 usando o gerador x n = 75xn-1 mod (231-1). Classificar os
números em 10 classes de tamanhos iguais e teste a uniformidade pelo teste CQ com confiança de 95 e
99%.
3. Gerar 15 números usando a semente x0 = 1 no gerador xn = (5xn-1+1) mod 16. Verifique se a sequência
passa no teste CQ em um nível de confiança de 95 e 99%.
4. Teste os geradores apresentados no texto em um nível de confiança de 95% e 99%.
5. Trinta números aleatórios foram gerados usando o GCL x n = 3xn-1 mod 31 com semente de x0 = 15. Os
números foram: 14, 11, 2, 6, 18, 23, 7, 21, 1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28,
22, 4, 12, 5, 15. Verifique se eles são iid.
6. Teste a fórmula recursiva da Equação Erro: Origem da referência não encontrada para os GCL's GCC,
JAVA e MMIX, para as sementes 0, 1, 31, 35 e 1000.
7. Refaça a Tabela 4.1 para xn+1 = (5xn+ 1) mod 24 e discuta seus resultados.
8. Qual é o período dos GCL:
a) xn+1 = 5xn mod 25

b) xn+1 = 7xn mod 25
9. Considere os casos descritos por Bandyopadhyay e Bhattacharya para propor e testar um gerador de
números aleatórios para um hardware com palavra de:
a) 8 bits
b) 11 bits
c) 14 bits
11 GERAÇÃO DE VARIÁVEIS ALEATÓRIAS
As atividades de pesquisa e desenvolvimento em engenharia fazem uso extensivo de

simulação em computadores. Como grande parte dos sistemas físicos são afetados por
fenômenos físicos aleatórios, é importante que essas simulações sejam capazes de
reproduzi-los. Em geral, essas simulações utilizam variáveis aleatórias e gerá-los constitui
uma importante etapa destas atividades.
Uma variável aleatória é uma função que mapeia os eventos definidos em um espaço
amostral no conjunto de valores [0,1]. Diferentes variáveis aleatórias podem ser associadas a
um experimento, o que permite expressar tanto a sua complexidade quanto a variação do
seu comportamento através das mais diversas funções densidade de probabilidade, tornando
possível sua simulação.
Segundo Gentle (2004), em estatística computacional, a geração de variáveis aleatórias

normalmente é feita em duas etapas:
1. a geração de variáveis aleatórias independentes e identicamente distribuídos U com a distribuição

uniforme no intervalo (0,1)
2. aplicar transformações a estas variáveis aleatórias iid U(0,1) para derivar variáveis aleatórias de
distribuições arbitrárias, Figura 11.1
Figura 11.1 Transformação de variáveis aleatórias U(0,1) em distribuições arbitrárias pelo

método da inversa.
Essas duas etapas são essencialmente independentes. O passo 1 é obtido por meio
geradores de números aleatórios (GNA) e o passo 2 é resolvido pelo método da inversa.
Em princípio, a maneira mais simples de gerar variáveis aleatória X com função de

distribuição F a partir de U(0,1) variáveis aleatórias U é aplicar a inversa F a U:
X = F-1(U) ≡ min{x | F(x) ≥ U}
Este é o método da inversa. É fácil verificar que X tem a distribuição desejada: P[ X ≤ x ] = P[

F-1(U) ≤ x ] = P[ U ≤ F(x) ] = F(x).
Ou seja, gerar variáveis aleatórias Xi de uma função densidade de probabilidade f(x) é

resolver a equação Xi = F-1(ui) em que F(x) é a função densidade de probabilidade acumulada
e ui ∼ U(0,1).
Nem sempre x = F-1(u) tem solução analítica, devendo ser considerado os seguintes fatores
para seleção do método de geração de variáveis aleatórias:
• exatidão - deve-se usar sempre métodos exatos e utilizar métodos baseados em aproximação em último
caso
• eficiência - dentre os diversos métodos exatos deve-se sempre escolher o mais eficiente
• simplicidade - em geral é preferível utilizar métodos simples
11.1 Método da Inversa da FDA
O Método da Inversa da Função Distribuição Acumulada (FDA) é um dos métodos mais

simples de geração de variáveis aleatórias de uma distribuição F contínua e estritamente
crescente. Nessas condições pode-se gerar uma variável aleatória utilizando o seguinte
algoritmo:
4. Gerar u ~ U(0,1)
5. Calcular x = F-1(u), onde F-1(u) é o valor de x quando F(x) = u
Uma grande desvantagem deste é que seu uso esta limitado a distribuições que possuem
FDA inversível como, por exemplo, as distribuições Exponencial, Logística e Pareto, Gumbel
ou Valores Extremos e Weibull. A Tabela 11.1 lista estas distribuições de probabilidade, suas
fdp, fda e x, a técnica de GVA destas fda, onde u ~ U(0,1).
Tabela 11.1 Distribuições de probabilidade, fdp, fda e x, a técnica de GVA destas fda, onde u
~ U(0,1).
Distribuição f(x) F(x) x
Exponencial a exp(−a x) 1−exp (−a x) −a ln( u)
1
1 2 x−m 1
Logística sech ( ) x−m m−s ln ( −1)
4s 2s 1+exp [−( )] u
s
1
a
1 1 1 1
Pareto ( ) (1− a−1 ) [ ] a−1
x a−1 x 1−u (a−1)
1 x −m x−m x −m
Valores Extremos exp[− −exp(− )] exp[−exp (− )] m−s ln [−ln(u)]
s s s s
a x a−1 x a x a 1
Weibull ( ) exp[−( ) ] 1−exp [−( ) ] b[−ln(u)] a
b b b b
No Capítulo 17 estão descritos os procedimentos matemáticos para Gerar Variáveis

Aleatórias das fdp Exponencial, Logística e Pareto, Gumbel ou Valores Extremos e Weibull,
listadas na Tabela 11.1.
Exemplo 11.1 Gerar variáveis aleatórias X i de uma função densidade de probabilidade f(x) é
resolver a equação Xi = F-1(ui) em que F(x) é a função densidade de probabilidade
acumulada e ui ∼ U(0,1).
x
Para obter Xi = F (ui) pode-se resolver a equação integral
-1
∫ f ( x )dx=u
−∞
, que nem sempre
tem solução analítica.
Para aquelas funções em que x = F -1(u) não possuem solução analítica, foram idealizadas
algoritmos engenhosos que, embora sejam aproximados, substituem os métodos numéricos
de modo satisfatório, evitando esforços computacionais além do necessário, como nas
integrações numéricas.
11.2 Método da Convolução
Para várias distribuições estatísticas importantes, a variável aleatória desejada X pode ser
expressa como a soma de outras variáveis aleatórias, cuja geração pode ser feita de maneira
mais rápida do que geração direta de X. Supõe-se que X seja a soma de m variáveis
aleatórias iid da forma X = Y1 + Y2 + ... + Ym. Pode-se utilizar o seguinte algoritmo:
6. Gerar Y1, Y2 , ..., Ym, cuja distribuição de probabilidade é Y

7. Retornar X = Y1 + Y2 + ... + Ym.
Este método pode ser aplicado para todas as distribuições que são a soma de variáveis
aleatórias. Como a distribuição Binomial pode ser expressa como a soma de variáveis
aleatórias da distribuição Bernoulli, que são muito mais fáceis de serem obtidas.
Da mesma forma, a distribuição Binomial Negativa pode ser expressa como a soma de
variáveis aleatórias da distribuição Geométrica, que também são muito mais fáceis de serem
obtidas.
11.3 Método da Composição
A variável aleatória desejada X pode ser expressa como uma combinação linear X = c 1Y1 +
c2Y2 + ... + cnYn onde Σci=1. Pode-se utilizar o seguinte algoritmo:
8. Gerar as distribiuições de probabilidade Y1, Y2 , ..., Yn

9. Obter ou gerar c1, c2, ..., cn tal Σci=1
10. Retornar Y = ΣciYi
11.4 Método da Aceitação Rejeição
Assumindo que uma distribuição F, contínua, possui fdp f(x), deve-se encontrar uma
distribuição alternativa G cuja fdp g(x) englobe o mais perfeitamente possível f(x), ou seja,
que seja majoritária sobre ela, Figura 11.2, a função G é também chamada de função
envelope.
Figura 11.2 Ilustração do Método da Aceitação-Rejeição
Um dos possíveis algoritmos que descrevem o Método da Aceitação Rejeição é descrito a

seguir:
11. Gerar u ~ U(0,1)

12. Gerar uma variável Y com distribuição G independente de u
13. Se u ≤ f(Y)/[cg(Y)] então ao faça x = Y (Y é aceito), caso contrário, volte ao passo 1 (Y é rejeitado)
14. x é uma variável aleatória com distribuição F
A Figura 11.2 ilustra as funções envolvidas no algoritmo apresentado acima. Nela, pontos são
gerados dentro do intervalo de g(x). Desses pontos, aqueles que caem dentro dos limites de
f(x) são aceitos, e os que caem fora são rejeitados.
Exemplo 11.2 Obtenha o algoritmo para a geração de variáveis aleatórios Normais padrão pelo método da
Método da Aceitação Rejeição.
A fdp de uma variável aleatória Z com distribuição z ~ N(0,1) é dada por f(z) = 2 exp(-z 2/2)/(2π)1/2. Será
utilizada a função exponencial g(x) = e-x/2 para majorar f(z), com f, g: R→R. A Figura 11.3 ilustra o
comportamento destas funções para valores positivos das abscissas.
Figura 11.3 Gráfico de f(t) = 2 exp(-t2/2)/(2π)1/2 e g(t) = e-t/2 para t ≥ 0.

Fazendo f(x)/g(x) = exp(-x2/2)/(2π)1/2/e-x/2 = exp(x/2-x2/2)/(2π)1/2.
Para resolver a equação c = max[f(x)/g(x)] basta derivar f(x)/g(x) em relação a x e igualar a zero
(d[f(x)/g(x)]/dx=0).
Verificar que para x = 1 a razão f(x)/g(x) é máxima, logo c = f(1)/g(1) = 2/(2π) 1/2
Neste caso, f(x)/[c*g(x)] = exp(x/2-x2/2) e pode-se escrever o seguinte algoritmo:

1. gerar dois números aleatórios u1 e u2,
2. gerar uma variável aleatória G = 2*ln(u1),
3. se u2 < exp(G/2-G2/2) então faça x = G senão retorna ao procedimento 1
4. retornar x
Este algoritmo gera apenas valores positivos da fdp Normal, útil para gerar grandezas temporais.
Sobre o procedimento 2: como g é exponencial será utilizado o método da Inversa. Recomenda-se que a função
envelope seja do tipo x = F−1(u), tenha inversa analítica.
De modo geral, valores de qualquer distribuição de probabilidade podem ser obtidos pelo
Método da Aceitação Rejeição. A distribuição Beta é uma delas.
11.5 Gerar FDA

Para evitar resolver a equação integral,
1
1 2 x−m 1
4s 2s 1+exp [−( )] u
s
1
a
1 1 1 1
Pareto ( ) (1− ) [ ] a−1
x a−1 x a−1 1−u (a−1)
s s s s
a−1 a a
a x x x 1
Weibull ( ) exp[−( ) ] 1−exp [−( ) ] b[−ln(u)] a
b b b b
que nem sempre tem solução analítica, foram propostas aproximações (soluções empíricas)
para algumas FDA41, como ilustrado abaixo.
FDA Exponencial
A fdp de uma variável aleatória x com distribuição exponencial é dada por:
p(x) = λe-λx, x ≥ 0, λ > 0.
O parâmetro λ é o número médio de ocorrências por unidade de tempo e a razão 1/λ

expressa o tempo médio entre as ocorrências.
Ao aplicar o método da transformação inversa para a obtenção de uma variável aleatória x
com distribuição exponencial é necessário:
1. obter a distribuição cumulativa de probabilidade F(x) = P(X ≤ x), o que resulta em F(x)
= ∫p(x)dx = ∫ λe-λxdx = 1-e-λx ↔ F(x) = 1-e-λx
2. gerar um número aleatório u e fazer F(x) = u ↔ P(X ≤ x)
3. resolver u = 1-e-λx para x, o que resulta em x = -λln(1-u)
4. como 1-u e u possuem distribuição uniforme no intervalo [0,1], pode-se substituir (1-u)
por u
5. logo x = -λln(u) é uma variável aleatória x com distribuição exponencial de parâmetro
λ
6. o valor de x foi obtido por meio de u que, por sua vez, foi obtido de um GNA
FDA Poisson
A distribuição de Poisson, estima a probabilidade de ocorrência de x sucessos em um dado
intervalo de tempo, por meio da seguinte função densidade de probabilidade:
p(x) = p(X = x ) = e-λλx/x!, x ≥ 0, λ > 0,
em que λ é o valor esperado do número de ocorrências por unidade de tempo.

Os procedimentos computacionais para a geração de uma variável aleatória Poisson, pelo
método da Aceitação/Rejeição, são os seguintes:
1. fazer n = 0 e p =1,
2. gerar um número aleatório un+1 e fazer p = p∗un+1,
3. se p < e-λ então aceitar X = n senão fazer n = n+1 e retornar ao procedimento 2
4. retornar X.
41 Com os computadores atuais a resolução numérica da equação integral é viável pois tem baixo custo computacional.
FDA Normal
A transformação de Box-Muller consiste na geração de pares de amostras aleatórias
independentes com distribuição normal a partir de números aleatórios uniformemente
distribuídos. Sejam u, v ~ U(0,1) e x, y ~ N(µ,σ2), tem-se que:
• x=μ+σ cos(2 π u) √−2 ln(v )
• y=μ+ σ sin(2 π u) √−2 ln (v )
Trata de um método estatístico muito simples e eficaz – qualidades extremamente

desejáveis.
FDA Normal 2
Uma outra maneira de gerar variáveis aleatórias com distribuição normal é a aproximação
obtida a partir do Teorema do Limite Central, que consiste em gerar 12 variáveis u ~ U(0,1),
somá-las e subtrai 6. A variável aleatória resultante tem distribuição normal
aproximadamente padrão com valores em (-6,+6).
12
z=∑ ui −6 , z ∊ (-6,+6) e z ~ N(0,1); x=μ+σ z , x ~ N(µ,σ2).
i=1
FDA Gamma
A soma de b variáveis aleatórias exponencialmente distribuídas tem distribuição gamma.
b b
a b x b−1 e−ax 1 1
f ( x)= , x=− ∑ ln (ui )=− ln ∏ u i , x ~ G(a,b).
(b−1)! a i =1 a i=1
11.6 Qualidade na Geração de Variáveis Aleatórias
É importante fazer testes nas amostras geradas para verificar a qualidade da sequência
aleatória, como os testes de uniformidade e de aderência à distribuição de interesse. Neste
sentido, recomenda-se os testes CQ como testes de aderência.
11.7 Algoritmos para Gerar Variáveis Aleatórias
A classe clGVA(), Algoritmo 11.1,implementa em Javascript funções para gerar variáveis

aleatórias das principais FDA de uso em simulação. Ela faz uso de clGNA para gerar números
aleatórios.
Algoritmo 11.1 Classe clGVA() em Javascript possui funções para gerar variáveis aleatórias
das principais fda de uso em simulação
function clGVA(){
var GNA = new clGNA();
this.Bernoulli = function(p){
if( GNA.gna() > p ) return 0;
return 1; //Law(2007)
}
this.Beta = function(a,b){
var x = this.Gama(a,1),
y = this.Gama(b,1);
return x/(x+y); //Law(2007)
}
this.Binomial = function(n,p){
var x = 0;
for( var i = 0; i < n; i++ )
x += this.Bernoulli(p);
return x; //Law(2007)
}
this.BinNegativa = function(s,p){
var x = 0;
for( var i = 0; i < s; i++ )
x += this.Geometrica(p);
return x; //Law(2007)
}
this.Erlang = function(b,m){
var p = 1.0;
for( var i = 0; i < m; i++ )
p *= GNA.gna();
return -b*Math.log(p)/m; //Law(2007)
}
this.Exponencial = function(a){
return -a*Math.log(GNA.gna()); //Law(2007)
}
this.Gama = function(a,b){
var p = 1.0;
for( var i = 0; i < b; i++ )
p *= GNA.gna();
return -Math.log(p)/a;
}
this.Geometrica = function(p){
return Math.ceil( Math.log(GNA.gna())/Math.log(1-p) ); // teto = ceil Law(2007)
}
this.Logistica = function(m,b){
return m-b*Math.log((1.0/GNA.gna()-1);
}
this.LogNormal = function(m,s){
return Math.exp(this.Normal(m,s)); //Law(2007)
}
this.Normal = function(m,s){
var u = GNA.gna(), v = GNA.gna();
return m + s*Math.sqrt(-2.0*Math.log(u))*Math.cos(2*Math.PI*v);
}
this.Pareto = function(a){
return Math.pow( 1/(1-GNA.gna()*(a-1)),1/(a-1));
}
this.Poisson = function(l){
var i = -1, a = Math.exp(-l), b = 1;
do{
i++;
b *= GNA.gna();
}while( b >= a ); //Law(2007)
return i;
}
this.Triangular = function(a,b,m){
var u = GNA.gna();
m = (m-a)/(b-a);
if( u > m ) return 1-Math.sqrt((1-m)*(1-u));
return Math.sqrt(m*u); //Law(2007)
}
this.UniformeContinua = function(a,b){
return a+(b-a)*GNA.gna(); //Law(2007)
}
this.UniformeDiscreta = function(i,j){
return Math.floor(i)+Math.floor((j-i+1)*GNA.gna()); // floor() = piso() Law(2007)
}
this.ValoresExtremos = function(a,b){
return a-b*Math.log(-Math.log(GNA.gna()));
}
this.Weibull = function(a,b){
return b*Math.pow(-Math.log(GNA.gna()),1/a); //Law(2007)
}
}
Exemplo 11.3 Faça um programa em C++ para gerar variáveis aleatórias da fdp Pareto utilizando o GNA Apple
CarbonLib.
O GNA Apple CarbonLib tem m = 2 31-1, a = 16807 e c = 0. A função gnacl gera dados deste GNA com semente
obtida do tempo do sistema.
A função Pareto gera variáveis aleatórias da fdp Pareto de parâmetro a e faz uso do GNA Apple CarbonLib
gnacl.
Por fim, tomando a = 3.0 como exemplo, são geradas 10 variáveis aleatórias da fdp Pareto fazendo uso do GNA
Apple CarbonLib.
#include <iostream>
#include <cmath>
#include <ctime>
double gnacl( void ){

m = pow(2,31)-1;
x = (16807*x)%m;
return double(x)/m;
}
double Pareto( double a ){
double u = gnacl();
return 1.0/pow(u,1.0/a);
}
int main(void){
double a = 3.0;
for( int i = 0; i < 10; i++ ){
cout << Pareto(a) << endl;
}
return 0;
}
Exemplo 11.4 Faça um programa em C++ para gerar variáveis aleatórias da fdp Normal utilizando o GNA Vax.
O GNA Vax tem m = 231, a = 69069 e c = 1. A função gnavax gera dados deste GNA com semente obtida do
tempo do sistema.
A função Normal2 gera variáveis aleatórias da fdp Normal de parâmetros m e s e faz uso do GNA Vax.
Por fim, tomando m = 3.0 e s =2.0 como exemplo, são geradas 10 variáveis aleatórias da fdp Normal fazendo
uso do GNA Vax.
#include <iostream>
#include <cmath>
#include <ctime>
#define PI 3.1415926535897932384
double gnavax( void ){

m = pow(2,31);
x = (69069*x+1)%m;
return double(x)/m;
}
double Normal2( double m, double s ){
double u1 = gnavax(),
u2 = gnavax();
return m+s*sin(2.0*PI*u1)*sqrt(-2.0*log(u2));
}
int main(void){
double m = 3.0, s = 2.0;
for( int i = 0; i < 10; i++ )
cout << Normal2(m,s) << endl;

return 0;
}
11.8 Gerar Processos de Chegada
Conhecendo-se os parâmetros da função densidade de probabilidade que governa o processo

de chegada, deve-se gerar quantas variáveis aleatórias forem necessárias para processar os
pacotes de chegada.
Se a função for Poisson, o intervalo médio entre chegadas é o parâmetro necessário para se
gerar os processos de chegada.
Os parâmetros de uma função podem ser calculados por meio de estatísticas obtidas a partir
de amostras do processo e, embora ele seja discreto, deve-se buscar ajustar a melhor função
densidade de probabilidade, quer seja discreta ou contínua, dentre as disponíveis.
11.9 Questões
1. Qual é a diferença entre os símbolos u e U, conforme este texto.
2. Qual é a diferença entre número aleatório e variável aleatório.
3. Identificar as fda deste capítulo que podem ter variáveis aleatórias geradas pelos métodos
da:
• transformação inversa
• rejeição
• composição
• convolução
11.10 Exercícios
1. Gere variáveis aleatórias utilizando os algoritmos propostos neste capítulo e verifique sua
aderência à distribuição com os testes CQ. Faça o teste para 50, 100 e 200 valores gerados
com confiança de 95 e 99%.
2. Compare os resultados de variáveis aleatórias geradas pelos algoritmos propostos neste

capítulo com os do C++11. Faça o teste para 50, 100 e 200 valores gerados com confiança
de 95 e 99%.
3. Implemente um algoritmo para a geração de variáveis aleatórias Normais padrão f(z) pelo
Método da Aceitação-Rejeição utilizando a função exponencial g(t) = e -t/k para majorar f(z)
com z ≥ 0 e k = 3, 4, 5, 10.
4. Implemente, em C++11, o algoritmo desenvolvido no Exercício 3 e compare o número de

execuções para k = 2, 3, 5 e 10.
5. Gere 100 variáveis aleatórias Exponential em C++11 e verifique sua aderência a esta
distribuição com os testes CQ com confiança de 99%.
6. Gere 100 variáveis aleatórias Poisson em C++11 e verifique sua aderência a esta
distribuição com os testes CQ com confiança de 99%.
12 SELEÇÃO DE DISTRIBUIÇÕES DE PROBABILIDADE
A estrutura conceitual para a modelagem e a análise estatística de um sistema é esboçado

na Figura 12.1. O ponto de partida de um problema é o mundo real e um conjunto
correspondente de dados do problema, a amostra. O segundo passo consiste em encontrar
um modelo matemático estocástico ou probabilístico para os dados. Este modelo deve conter
o que se sabe sobre o mundo real. O modelo permite realizar cálculos e análises que levam a
conclusões sobre a amostra. Finalmente, as conclusões sobre o modelo são convertidas para
conclusões sobre o mundo real. Desta forma, a partir da amostra pode-se fazer afirmações
sobre o mundo real fazendo-se uso de modelos.
Figura 12.1 Modelagem e análise matemática (Kroese & Chan, 2014).
A Estatística usa a teoria da probabilidade e outros ramos da matemática para estudar dados
amostrais. Em particular, os dados são vistos como aplicações de variáveis aleatórias cuja
distribuição conjunta é previamente especificada. A partir daí, a análise matemática atua
puramente sobre o modelo e seus parâmetros (Kroese & Chan, 2014).
A noção de probabilidade é a de um experimento aleatório cujo resultado não pode ser

previamente determinado mas que pode ser analisado. O objetivo da probabilidade é
entender o comportamento de experimentos aleatórios através da análise matemática. Dado
um modelo matemático para um experimento aleatório, pode-se calcular as quantidades de
interesse, como probabilidades e valores esperados. Além disso, esses modelos matemáticos
podem ser implementados em computador, assim torna-se possível simular experimentos
(Kroese & Chan, 2014).
Para identificar uma distribuição de probabilidade que represente o comportamento de uma

variável aleatória é necessário uma amostra e métodos estatísticos que proporcionem a
ligação entre modelos matemáticos estocásticos e o mundo real.
Teste de aderência são métodos estatísticos que permitem avaliar o ajuste de uma
distribuição de probabilidades aos dados de uma variável aleatória, o que permite descrever
seu comportamento.
A Figura 12.2 ilustra o processo de gerar dados representativos para simulação a partir de
amostras de dados de um sistema computacional.
Figura 12.2 Processo de gerar dados para simulação a partir de amostras de dados de um
sistema computacional.
A Tabela 12.1 descreve as cinco etapas necessárias para se obter uma distribuição de
probabilidades capaz de representar o comportamento uma variável aleatória (Jain, 1991).
Tabela 12.1 Etapas para a aplicação de testes de aderência, adaptadas de Jain (1991).
• a amostragem é um conjunto de dados medidos que represente o

comportamento do sistema
• amostras representativas permitem que resultados obtidos por
1. Processo de Amostragem meio delas sejam estendidos à população, isto é, podem ser
generalizados
• resultados obtidos através de amostras não representativas do
comportamento do sistema não podem ser generalizados
• valores extremos da amostra devem ser identificados e

desconsiderados
• deve-se agrupar os valores amostrados em classes
2. Tratamento dos Dados • gráficos de valores amostrados permitem avaliação visual dos
mesmos, sus distribuição e propriedades estatísticas
• gráfico box-plot dos valores amostrados complementam a
avaliação visual dos mesmos
3. Identificação da • uma ou mais distribuições de probabilidade que se adéquem aos

Distribuição Estatística dados amostrados devem ser identificadas
4. Estimação dos
• os parâmetros da distribuição ou distribuições de probabilidades
Parâmetros da Distribuição identificadas devem ser estimados a partir dos dados amostrados
Identificada
• deve-se testar o ajuste dos dados amostrados à distribuição ou
5. Testes de Aderência distribuições de probabilidades identificadas por meio de testes
de aderência
A simulação computacional de Sistemas de Fila requer duas amostras:
1. A primeira amostra se refere ao processo de chegada de pacotes na Fila do sistema, os dados

amostrados são intervalos de tempo entre chegadas de pacotes ou taxa de chegada.
2. A segunda amostra diz respeito ao processamento dos pacotes pelo Servidor do sistema, os dados
amostrados são tempos de serviço ou taxa de serviço.
Para cada uma destas amostras deve-se ajustar uma distribuição de probabilidade e ambas
são utilizadas para representar o comportamento do sistema, uma para gera valores de ic e a
outra para gerar valores de ts.
Com poucos dados não se pode fazer simulação confiável. Este processo viabiliza a
simulação ao permitir gerar incontáveis dados que, embora sejam gerados por modelos
matemáticos, representam o comportamento do sistema e levam a conclusões válidas para
o mundo real.
A partir de poucos dados medidos pode-se estimar uma fdp do comportamento e variáveis
do sistema e, a partir desta fdp, pode-se gerar novos dados destas variáveis, quantos forem
necessários.
A obtenção de dados experimentais pode ter custo elevado e esta metodologia estatística
permite fazer mais com menos: gerar muitos dados do sistema computacional a partir de
poucos dados medidos e representativos.
12.1 Independência de Observações
Qualquer estado de um Processo de Markov é independente dos seus estados passados e,

sendo assim, as amostras de um Processo de Markov devem ser independentes.
A autocorrelação é uma estatística que informa o quanto o valor de uma variável aleatória é
capaz de influenciar seus vizinhos à distância k, k > 0. Os valores que a autocorrelação
podem assumir variam de -1 a 1, a ausência de correlação é indicada por 0, ou seja, as
observações da amostra são independentes.
Uma variável aleatória Xi discreta, com média da população μ = E(X) e variância σ 2 = E[(X-
μ)2], tem autocorrelação ρ(k) definida por:
n−k
E[( X i −μ)( X i+k −μ)]

∑ ( X i−μ)( X i+k−μ)
i=1
ρ(k )= 2
= n
12.1
σ
∑ ( X i−μ)2
i=1
Exemplo 12.1 Calcule ρ(1) e ρ(2) dos dados referente a ciclos de leitura de 5 unidades de memória: x = {37,0
54,2 55,1 28,1 24,0}.
n=5
Cálculo da média amostral m: m = (37,0+54,2+55,1+28,1+24,0)/5 = 198,4/5 = 39,7
Cálculo da variância da amostra s 2: s2 = [(37,0-39,7)2+(54,2-39,7)2+(55,1-39,7)2+(28,1-39,7)2+(24,0-39,7)2]/(5-
1) = 835,7/4 = 208,9
Cálculo de ρ(1) = [(37,0-39,7)x(54,2-39,7) + (54,2-39,7)x(55,1-39,7) + (55,1-39,7)x(28,1-39,7) + (28,1-
39,7)x(24,0-39,7)]/(5-1)/208,9 = (188,0/4)/208,9 = 47,0/208,9 = 0,225.
Este valor indica que os dados estão pouco correlacionados.
Cálculo de ρ(2) = [(37,0-39,7)x(55,1-39,7) + (54,2-39,7)x(28,1-39,7) + (55,1-39,7)x(24,0-39,7)]/3/208,9 = (-
451,3/3)/208,9 = -150,4/208,9 = -0,72.
Memória de cálculo:
i xi xi-m (xi-m)x(xi+1-m) (xi-m)x(xi+2-m)
1 37,0 37,0-39,7 (37,0-39,7)x(54,2-39,7) = -2,7 (37,0-39,7)x(55,1-39,7) = -41,3
2 54,2 54,2-39,7 (54,2-39,7)x(55,1-39,7) = 14,5 (54,2-39,7)x(28,1-39,7) = -168,1
3 55,1 55,1-39,7 (55,1-39,7)x(28,1-39,7) = 15,4 (55,1-39,7)x(24,0-39,7) = -241,8
4 28,1 28,1-39,7 (28,1-39,7)x(24,0-39,7) = -11,6
5 24,0 24,0-39,7
∑ 198,4 15,7 -451,3

m39,7
s 14,5
Uma forma de avaliar visualmente a independência dos dados de uma amostra é o gráfico de
dispersão, que é feito pelos pares ordenados (xi,xi+k) em um plano cartesiano. Quando eles
são independentes estão dispersos aleatoriamente, caso contrário estão próximos de uma
reta.
Exemplo 12.2 Faça o gráfico de dispersão dos pares ordenados (xi,xi+1) em um plano cartesiano para x = {37,0
54,2 55,1 28,1 24,0}.
Figura 12.3 Gráficos de dispersão dos pontos (xi,xi+1) do Exemplo 12.3.
12.2 Distribuições de Probabilidade Úteis
As funções densidade de probabilidade (fdp) são inúmeras e bem diversificadas embora

relacionadas. Leemis (2015) e Zwillinger & Kokoska (2000) apresentam figuras ilustrando a
relação entres as diversas fdp. A Figura 12.4 ilustra o relacionamento entres funções
densidade de probabilidade, adaptado de Zwillinger & Kokoska (2000).
Figura 12.4 Relacionamento entres as funções densidade de probabilidade, adaptado de

Zwillinger & Kokoska (2000).
A Tabela 12.2 apresenta as funções densidade de probabilidade mais relevantes para

simulação.
Tabela 12.2 Funções densidade de probabilidade mais relevantes com seus parâmetros,
média e variância (Forbes et al., 2011)
fdp FDP Parâmetros E(x) V(x)
λ m x m−1 e−λ x m m
Erlang-m , x≥0 λ>0
λ
(m−1)! λ2
−a x 1 1
Exponencial ae , x>0 a>0
a a2
2
(x−μ)
1 − 2 μ ∊ (-∞,∞)
Normal e 2 σ , x ∈ℝ σ>0
μ σ2
σ √2 π
x −λ
λ e
Poisson , x≥0 λ>0 λ λ
x!
1 a+b (b−a)
2
Uniforme , x ∈[a ,b ] a<b
2
b−a 12
x b
−( )
bx
b−1
ea a>0 b+1 2 b+2 2 b+1
Weibull aΓ( ) a [Γ ( )−Γ ( )]
b
, x≥0 b>0 b b b
a
∞
em que Γ( a)=∫ x e dx .
a−1 −x
Em Processos de Markov os eventos passados não influem nos eventos presentes, ou seja,
para s e t > 0 então P( X > s+t | X > s ) = P( X > t ), usualmente denominados processos
sem memória.
A distribuição Exponencial, f(x) = λe-λx, é sem memória42 (Kroese & Chan, 2014).
x
A função densidade acumulada (FDA) F(x) = P(X ≤ x ) = ∫ f (x)dx = 1-e-λx ∴ P(X > x ) = 1-
0
P(X ≤ x ) = e-λx
12.3 Estimação de Parâmetros
O método de máxima verossimilhança, assim como o método de mínimos quadrados,

permitem a estimação dos parâmetros de modelos matemáticos. O grande obstáculo para
sua utilização consiste na frequente incapacidade de se obter uma solução explícita para os
problemas em questão.
12.3.1 Método da Máxima Verossimilhança
Uma amostra aleatória (X1, X2, ..., Xn) retirada de uma população com uma função de
densidade de probabilidade f(x,θ), em que θ é um vetor de parâmetros, tem uma função
densidade de probabilidade conjunta, a função de verossimilhança L(x,θ), definida pelo
produto das funções densidade de cada uma das observações.
n
L(x ,θ)=∏ f ( x i , θ) 12.2
i=1
O problema consiste em obter o vetor θ que maximiza L(x,θ), o que é feito igualando a zero
as derivadas parciais da função de verossimilhança em relação ao vetor θ
n
∂ ∏ f ( xi , θ) 12.3
∂ L( x ,θ) i =1
∂θ = ∂θ =0
Na maioria dos casos é recomendável utilizar logaritmo natural da função de verossimilhança
(lnL), pois maximizar o logaritmo natural de uma função é, em geral mais simples, e produz
os mesmos resultados da maximização da função original.
n
∂ ln ∏ f (x i , θ) 12.4
∂ln L(x ,θ) i=1
= =0
∂θ ∂θ
Exemplo 12.3 Seja determinar o parâmetro β da fdp Exponencial pelo método da Máxima Verossimilhança a
partir de uma amostra aleatória (X1, X2, ..., Xn).
∂ L( x ,θ)
=0
∂θ
x
1 −
f ( x , β)= e β e θ={β}
β
n Xi
1 −β
L(x ,β)=∏ e
i=1
β
n
X1 X2 Xn 1
1 − − − 1 − 1 (X + X +⋯+ X ) 1 −β ∑ X i
L(x ,β)= n ( e β +e β +⋯+ e β )= n e β

1 2 n
= ne i=1
β β β
n n
1 1 n n
1 −β ∑ X 1 − ∑X
1 1
)=−ln(β )− ∑ X i=−n ln(β)− ∑ X i
β i
n i
ln L(x ,β)=ln ( n e )=ln ( n )+ln (e i=1 i=1
β β β i=1
β i=1
42Demonstração: P(X > s+t | X > s) = P(X > s+t, X > s)/P(X > s) = P(X > s+t)/P(X > s) = e -λ(s+t)/e-λs = e-λt = P( X > t ) c.q.d.
n
1 1
β∑
∂[−n ln(β)− Xi] n ∂ n
∂ln L(x ,β) ∂ ln (β) β 1 n
= i=1
=−n −∑ X i = 2 ∑ X i− =0
∂β ∂β ∂β i =1
∂β β i=1 β
n n
1 n 1
2∑
X i = ⇔β= ∑ X i
β i=1 β n i=1
12.3.2 Método dos Mínimos Quadrados
O método de estimação por mínimos quadrados (MMQ) permite estimar os valores dos
parâmetros de uma função a partir de dados observados que minimiza o quadrado do
somatório dos erros entre valores observados e estimados.
Uma amostra aleatória (fo1, fo2, ..., fon) com função densidade de probabilidade fe(x,θ), em
que θ é um vetor de m parâmetros pk, k ∈ [1,m], tem uma função de densidade de
probabilidade dada por foi=fe(xi,θ)+εi, i ∈ [1,n].
O erro (ε) entre valores observado e estimado é dado pela Equação 12.5 e a somatória do
quadrado dos erros (E) é expresso pela Equação 12.6.
e i=fo(x i )−f ( x i , θ) 12.5
n n
E=∑ e2i =∑ [ fo(x i )−f (x i , θ)]2 12.6
i=1 i=1
Como E possui mínimo, a solução do sistema de m equações ∂E/∂pk = 0 permite calcular o

valor do vetor θ que minimiza E. A solução geral é dada pela Equação 12.7.
n n
∂∑ e ∂ ∑ [fo ( x i)−f ( x i ,θ)]
2 2
n
∂E
i
∂ f (xi , θ) 12.7
=−∑ {[fo( x i )−f ( x i , θ)]
i=1 i=1
∂θ = ∂θ = ∂θ i=1
∂ θ }=0
Conhecidos os valores observados fo(xi) nos pontos xi, i ∈ [1,n], pode-se substituir estes
valores na Equação 12.7 e calcular θ.
12.4 Estimativa dos Parâmetros das FDP
As estimativas dos parâmetros de uma distribuição de probabilidade, por vezes, não é de

obtenção imediata. Os parâmetros das distribuições Exponencial, Normal e Poisson, dentre
aquelas listadas na Tabela 12.2, são calculados a partir da média e desvio padrão da
amostra. O cálculo dos parâmetros das fdp Beta, Gamma e Weibull são ilustrados abaixo.
12.4.1 Estimativa dos parâmetros da fdp Exponencial
x
1 −
A fdp Exponencial pode ser definida como f (x)= e a ou como f (x)=be−bx , com parâmetros
a
1
a=E[ x ] e b= , respectivamente, Tabela 12.3.
E [x ]
Tabela 12.3 Definições da fdp Exponencial e seus parâmetros

fdp Parâmetro
x
1 − 1
f ( x)= e a a=E[ x ]= ∑ xi
a n
1 n
f (x)=be
−bx b= =
E [x ] ∑x i
12.4.2 Estimativa dos parâmetros da fdp Beta
Segundo Leite e Virgens Filho (2011), os parâmetros p e q da distribuição Beta

1 Γ ( p+q) x−a p −1 x−a q −1
f (x)= ( ) (1− ) , para X = { x1, x2, ..., xn}, são estimados pelo
b−a Γ ( p) Γ(q) b−a b−a
algoritmo:
x i−a
1. calcular V ={ v1, v2, ..., vn } sendo v i= em que a = min{X} e b = max{X}
b−a
n
1
2. calcular m 1= ∑v
n i=1 i
n
1
3. calcular m 2= ∑
n i=1
2
vi
m 1 (m 1−m2)
4. calcular p= 2
m2 −m1
(1−m1 )(m1−m2)
5. calcular q=
m2−m21
6. Desta forma, a distribuição Beta é adimensionalizada para o intervalo [0,1], resultando na nova função
Γ( p+ q) p −1 q−1 v p−1 (1−v )q−1
f (v )= v (1−v ) = de parâmetros p e q.
Γ( p)Γ(q) B ( p , q)
Os cálculos dos testes CQ devem utilizar o vetor V.

Exemplo 12.4 Calcular os parâmetros da fdp Beta para a amostra X: { 6,91 1,61 4,99 9,11 9,03 9,71 0,05 5,98
5,20 9,83 }
Os dados serão ordenados como se segue.

i 1 2 3 4 5 6 7 8 9 10 m1 m2
xi 0,05 1,61 4,99 5,2 5,98 6,91 9,03 9,11 9,71 9,83
vi 0,000 0,159 0,503 0,524 0,603 0,698 0,914 0,922 0,983 0,995 0,630
vi2 0,000 0,025 0,253 0,274 0,364 0,487 0,835 0,849 0,966 0,990 0,504
a = 0,05
b = 9,83
p = 0,630*(0,630-0,504)/(0,504-0,630*0,630) = 0,736
q = (1-0,630)*0,736/0,630 = 0,433
Logo os parâmetros da fdb Beta são p = 0,736 e q = 0,433.
12.4.3 Estimativa dos parâmetros da fdp Gamma

Se X = { x1, x2, ..., xn } formam um conjunto de n valores, as estimativas dos parâmetros da

x
−
x a−1 e b
distribuição Gamma f (x)= a são feitas pelas equações (Thom, 1958; Catalunha et al.,
b Γ( a)
2012):
a=
1+ 1+
√
4A
4A
3
, b=
xm
a
1
n
1
n
, A=ln (x m )− ∑ ln( x i) e x m= ∑ x i .
n i=1 n i=1
Exemplo 12.5 Calcular os parâmetros da fdp Gamma para a amostra X: { 6,91 1,61 4,99 9,11 9,03 9,71 0,05
5,98 5,20 9,83 }
i 1 2 3 4 5 6 7 8 9 10 ∑ xm
xi 0,05 1,61 4,99 5,2 5,98 6,91 9,03 9,11 9,71 9,83 62,42 6,242
ln(xi) -2,996 0,476 1,607 1,649 1,788 1,933 2,201 2,209 2,273 2,285 13,425
n = 10
xm = (6,91 + 1,61 + 4,99 + 9,11 + 9,03 + 9,71 + 0,05 + 5,98 + 5,20 + 9,83)/10 = 6,24
∑ln(x) = ln(6,91) + ln(1,61) + ln(4,99) + ln(9,11) + ln(9,03) + ln(9,71) + ln(0,05) + ln(5,98) + ln(5,20) +
ln(9,83) = 13,43
A = ln(6,24) - 13,43/10 = 0,489
a = [1+(1+4x0,489/3)1/2]/(4x0,489) = [1+(1+0,651)1/2]/1,956 = (1+1,28)/1,956 = 1,17
b = 6,24/1,17 = 5,34
Logo os parâmetros da fdb Gamma são a =1,17 e b = 5,34.
12.4.4 Estimativa dos parâmetros da fdp Weibull
Segundo Hirata(2004), a estimativa dos parâmetros da distribuição de Weibull

b
x
−( )
b−1 a
bx e
f ( x)= b
para X = { x1, x2, ..., xn}, um conjunto n valores, são feitas pelas equações:
a
s −1,086 m
b=( ) e a= em que m e s são a média aritmética e o desvio padrão de X,
m 1
Γ(1+ )
b
respectivamente.
Exemplo 12.6 Calcular os parâmetros da fdp Weibull para a amostra X: { 6,91 1,61 4,99 9,11 9,03 9,71 0,05
5,98 5,20 9,83 }
i 1 2 3 4 5 6 7 8 9 10 ∑ m s
xi 0,05 1,61 4,99 5,2 5,98 6,91 9,03 9,11 9,71 9,83 62,42 6,242 3,397
b = (s/m)-1,086 = (3,397/6,242)-1,086 = (0,544)-1,086 = 1,936
a = m/Γ(1+1/b) = 6,242/Γ(1+1/1,936) = 6,242/Γ(1,516) = 6,242/0,887 = 7,038
Logo os parâmetros da fdb Weibull são a = 7,038 e b = 1,936.
12.5 Identificação da Distribuição Estatística

Para fins de simulação é necessário identificar a distribuição de probabilidade Fe que melhor

represente o comportamento do sistema. Para quantificar o grau de associação de uma
amostra de variáveis aleatórias X = (X 1, X2, ..., Xn) à distribuição Fe é utilizado testes de
aderência.
Testes de aderência fazem uso do teste de hipótese de ajuste à distribuição:
• Hipótese H0: X são observações da distribuição Fe

• Hipótese Ha: X não são observações da distribuição Fe
Etapas de um teste de hipóteses43:
1. formular o modelo estatístico para os dados

2. definir as hipóteses
3. definir uma margem de erro (α) em geral, adota-se α = 5%
4. selecionar a estatística de teste
5. calcular a estatística de teste
1. calcular a probabilidade limite (p-value)
2. decidir o teste: aceitar ou rejeitar H0 a partir do p-value
Vantagens:
• é uma forma automática de identificar diferenças grosseiras entre distribuições teórica e observada,
diferenças não provocadas pela flutuação dos dados
• não depende do julgamento do avaliador
Desvantagens:
• quando se tem poucos dados, o teste é pouco sensível (deixa de perceber diferenças, aceitando
distribuições com ajuste ruim)
• quando se tem muitos dados, as chances de se rejeitar todas as distribuições teóricas aumentam
• o teste de hipótese permite fixar a confiança 1-α em rejeitar uma distribuição, mas nada afirma quanto a
confiança em aceitá-la
Dentre as principais estatísticas de teste de aderência, destacam-se o de Chi-Quadrado.
12.5.1 Teste Chi-Quadrado (CQ)
O teste CQ é usado para testar se uma distribuição de frequência observada se ajusta a uma
distribuição específica, como a normal, exponencial ou outra qualquer. Ou seja, este teste
permite determinar se dados observados atendem a uma determinada distribuição de
probabilidade de p parâmetros. Sua aplicação consiste em:
• preparar um histograma com k classes para a obtenção da frequência de ocorrência observada O i em

cada intervalo i = 1, ..., k
• determinar a frequência de ocorrências esperadas E i para cada intervalo i obtida a partir da distribuição
que está sendo testada
k 2
(O i −E i )
• calcular a estatística D=∑ que tem distribuição χ2 com k-1-p graus de liberdade
i=1 Ei
• se D < χ2(1-α;k-1-p) não se pode rejeitar a hipótese H 0 ao nível de significância α, caso contrário rejeita-
se a hipótese H0.
A distribuição χ2 permite obter o valor de χ 2(1-α,gl) com significância α e gl graus de

liberdade.
O teste CQ:
43 Veja no apêndice notas sobre teste de hipóteses.
• funciona melhor se os intervalos do histograma são escolhidos de tal forma que os valores de E i sejam
iguais
• uma solução aproximada é agrupar um intervalo com Ei pequeno com algum intervalo vizinho
• no caso da distribuição uniforme, basta utilizar um histograma com intervalos de mesmo tamanho
Para o teste de aderência, a probabilidade limite do teste CQ é o termo técnico p-value e

corresponde à probabilidade P( X > xcrítico ) = 1-p-value.
Na Figura 12.5, o valor de xcrítico divide a área sob a curva em duas regiões, a região
hachurada em vermelho indica a probabilidade de se rejeitar a hipótese H0 ao nível de
significância p-value, isto é, D ≥ p-value. Em cinza, é a região de probabilidade em que não
se pode rejeitar a hipótese H0 ao nível de significância p-value, ou seja, D < p-value.
Figura 12.5 Regiões de probabilidade de aceitação (cinza) ou rejeição (vermelho) da

hipótese H0 ao nível de significância p-value para o teste CQ.
Passo a passo do teste CQ:

n
1. Dada uma amostra X ={x i }i=1
2. Classificar os dados da amostra X em k classes, Oi, i ∈ [1,k]
3. Calcula-se os parâmetros da amostra
7. Calcula-se pi, i ∈ [1,k], a partir da fdp desejada (pode requer integração numérica)
8. Calcula-se Ei, i ∈ [1,k]
9. Calcula-se D
10. Obtém-se o valor de xcrítico para o p-value a partir do Anexo e decide-se o teste
A frequência da classe i (fi), pode ser calculada pelo produto do número de observações (n =
∑ni) pela probabilidade de ocorrência de cada classe (fi = n × pi), i ∈ [1,k]. Para calcular o
valor de pi basta integrar a fdp desejada considerando os limites da classe.
xc
Para calcular xc = χ21-α-,υ deve-se resolver a equação integral ∫ f ( x) dx=1−α em que

0
ν −1 − x
1 2 2
f (x )= ν x e é a distribuição Chi-Quadrado υ graus de liberdade e Γ é a função gama. Estes
2 Γ(ν)
2
2
valores podem ser calculados numericamente ou obtidos de tabelas estatísticas (que são soluções desta
equação integral).
Exemplo 12.7 Deseja-se verificar se o número de falhas (NF) de um sistema muda conforme o dia da semana. O
número de falhas (NF) observadas para cada dia de uma semana escolhida aleatoriamente foram:
Dia da Semana NF Observadas (Oi)

segunda-feira 35
terça-feira 20
quarta-feira 30
quinta-feira 15
sexta-feira 10
sábado 10
domingo 20
Hipóteses a serem testadas:
• H0: o número de falhas não muda conforme o dia da semana

• Ha: pelo menos um dos dias da semana tem número de falhas diferente dos demais
Se pi representa a probabilidade de ocorrência de falhas no i-ésimo dia da semana:
• H0: pi = 1/7, ∀i ∊ {1, 2, …, 7}

• Ha: pi ≠ 1/7 para algum valor de i ∊ {1, 2, …, 7}
Total de falhas na semana: n = 140, Logo, se H0 for verdadeira, Ei = 140 × 1/7 = 20
Dia da Semana NF Observadas (Oi) NF Esperadas (Ei)

segunda-feira 35 20
terça-feira 20 20
quarta-feira 30 20
quinta-feira 15 20
sexta-feira 10 20
sábado 10 20
domingo 20 20
Cálculo de D = (35-20)2/20 +(20-20)2/20 + ... + (20-20)2/20 = 27,5
Regra de decisão: se, para α fixado obtemos D > χ2(1-α;gl), rejeita-se a hipótese H0, caso contrário aceita-se a
hipótese H0.
No caso da distribuição uniforme entre 0 e 1 nenhum parâmetro precisa ser estimado, p = 0

Da tabela do Anexo: χ2(0,95;6) = 12,59.
Neste caso, χ2(0,95;6) = 12,59 e D > χ2(0,95;6), isto é, 27,5 > 12,59.
Rejeita-se H0 e conclui-se que, pelo menos, um dos dias tem número de falhas diferente dos demais.
Conclusão: Pelo menos um dos valores medidos do tempo entre falhas do sistema difere dos demais segundo o
Teste de CQ com 95% de confiança.
12.5.2 Testes CQ para fdp Beta
Os testes de CQ para aderência de amostras à função Beta devem ser feitos com os dados
adimensionalizados para o intervalo [0,1].
12.6 Modelos para Processos de Chegada
O processo de chegadas de clientes numa fila é, em geral, estocástico. Para estudá-lo é

necessário identificar a distribuição de probabilidade do tempo entre chegadas que, em
geral, é exponencial.
Processos de chegada são ditos estacionários quando a distribuição de probabilidade que o

descreve não varia com o tempo (independente do tempo), caso contrário são ditos
processos não estacionários. Quando os tempos entre chegadas são identicamente
distribuídos, a taxa de chegada é igual à λ com média 1/λ.
A distribuição de Poisson é usada para encontrar a probabilidade de ocorrência de eventos

por unidade de intervalo. São condições para sua aplicação:
• deve existir apenas dois resultados mutuamente exclusivos {ocorre, não ocorre}
• os eventos devem ser independentes
• o número médio de ocorrências por unidade de intervalo deve permanecer constante
A distribuição de Poisson, Poi(λ), é apropriada para modelar eventos discretos independentes

e com taxa de ocorrência constante.
Um exemplo clássico é a representação do número de chegadas em Sistemas de Filas. Este

número tem uma distribuição de Poisson se a taxa média de chegada não variar ao longo do
tempo e se os tempos entre chegadas são exponencialmente distribuídos.
Na prática, as taxas de chegada podem variar de acordo com a hora do dia ou do ano, mas
um modelo de Poisson deve ser usado para períodos que são razoavelmente homogêneos.
Nesta distribuição a média e a variância são iguais e podem ser estimados pela observação
das características da amostra.
A distribuição de Poisson é de grande importância para a Teoria de Filas e para a área de

Confiabilidade. Ela permite estudar um grande número de fenômenos observáveis como, por
exemplo, a chegada de pacotes em filas, falhas de sistemas, requisição de pacotes em
servidores, falhas e, de modo geral, eventos que ocorrem por unidade de área ou de tempo.
Quando a taxa λ não varia com o tempo, a probabilidade de que haja a ocorrência de k
( λ T )k e−λ T
eventos no intervalo (0,T] é dada por f (k , λ)= . Uma generalização importante
k!
desse tipo de processo é quando se considera que λ varia no tempo, λ(t). Nesse caso, tem-se
um Processo Poisson não-estacionário e o número de chegadas m(T) é estimado pela
T
integração de λ(t) para t variando de 0 a T, m(T )=∫ λ(t) dt .
0
12.7 Gerando Processos de Chegada
Um Processo de Poisson com parâmetro λ é aquele cujo intervalos entre chegadas tem
distribuição exponencial do mesmo parâmetro λ. Seja ti o instante no qual a i-ésimo pacote
chega, o instante que a próxima pacote chega, t i+1, é dada por ti+1 = ti+Xi sendo Xi ~ Exp(λ).
Esta abordagem é utilizada nos softwares deste livro.
Uma outra abordagem para gerar N chegadas de Poisson durante um dado intervalo de
tempo de duração T, é usar o fato que estas N chegadas são uniformemente distribuídas ao
longo deste intervalo. Para gerar chegadas de Poisson no intervalo [0,T] faz-se:
1. gerar N números aleatórios (chegadas) de acordo com a distribuição de Poisson com parâmetro λT
2. gerar N números aleatórios distribuídos uniformemente correspondentes aos instantes t 1, ..., tN, no
intervalo [0,T]
3. ordenar os N instantes em ordem cronológica: t1 < ... < tN
12.8 Testando Homogeneidade de Amostras

Amostras de dados de um mesmo processo medidos em diferentes períodos podem

apresentar diferenças estatísticas. Por exemplo, a quantidade de serviços que chegam em
um sistema pode depender da hora do dia.
O método de Kruskal-Wallis é um teste não paramétrico que pode ser usado para determinar
se três ou mais amostras independentes foram selecionadas de populações que possuem a
mesma distribuição.
As hipóteses nula e alternativa para o teste de Kruskal-Wallis são as seguintes:
• H0: não há diferença na função distribuição de probabilidade das amostras

• Ha: há diferença na função distribuição de probabilidade das amostras
Segundo Spiegel et al. (2013), as duas condições para se usar o teste de Kruskal-Wallis são
que cada amostra deve ser selecionada aleatoriamente e que o tamanho de cada amostra
deve ser no mínimo 5. Se essas condições são alcançadas, a distribuição de amostragem
para o teste Kruskal-Wallis é aproximada por uma distribuição χ 2 com graus de liberdade k-1,
onde k é o número de amostras. Seja x ij a j-ésima observação da amostra i, a estatística de
teste do teste de Kruskal-Wallis é calculada pela equação:
k 2
12 Ri
T= ∑
n(n+1) i=1 n i
−3(n+1) 12.8
k ni
em que n=∑ ni , Ri=∑ R (x ij ) , ni é o número de observações da i-ésima amostra, R(x ij) é o

i=1 j=1
rank da observação ij sendo i ∈ [1,k] e j ∈ [1,ni].
O teste de Kruskal-Wallis consiste em combinar e classificar a informação da amostra, as

somas dos ranks de cada amostra são calculadas e usadas para calcular a estatística T, que é
uma aproximação das variâncias das somas dos ranks. Se as amostras são selecionadas de
populações que possuem a mesma distribuição, as somas dos ranks serão aproximadamente
iguais e, se T < χ2(1-α;k−1) H0 não pode ser rejeitada ao nível de confiança 1-α.
Exemplo 12.8 Verifique se as amostras A, B e C, referentes aos tempos de respostas de um circuito integrado,
possuem a mesma distribuição de probabilidade para α = 5%.
A B C
6,5 3,4 2,6
7,3 4,1 6,2
8,5 5,1 5,1
9,9 5,6 5,8
1,8 6,0 8,8
9,5 8,3 9,2
6,9 9,4 7,3
9,8 6,4
5,5
Solução: O cálculo do Rank pode ser feito por interpolação linear:

x1 1 x−x n Rank −n x−x n
x Rank = ⇒ Rank =(1−n) +n
xn n x 1−x n x 1−x n x1 −xn
Para n = 24, x1= 1,8 e xn= 9,9 tem-se os valores de Rank:

i,j A,B,C Rank
1 1,8 1
2 2,6 3,3
3 3,4 5,5
4 4,1 7,5
5 5,1 10,4
6 5,1 10,4
7 5,5 11,5
8 5,6 11,8
9 5,8 12,4
10 6 12,9
11 6,2 13,5
12 6,4 14,1
13 6,5 14,3
14 6,9 15,5
15 7,3 16,6
16 7,3 16,6
17 8,3 19,5
18 8,5 20
19 8,8 20,9
20 9,2 22
21 9,4 22,6
22 9,5 22,9
23 9,8 23,7
24 9,9 24
j A ARank B BRank C CRank

1 6,5 14,3 3,4 3,5 2,6 3,3
2 7,3 16,6 4,1 7,5 6,2 13,5
3 8,5 20,0 5,1 10,4 5,1 10,4
4 9,9 24,0 5,6 11,8 5,8 12,4
5 1,8 1,0 6 12,9 8,8 20,9
6 9,5 22,9 8,3 19,3 9,2 22,9
7 6,9 15,5 9,4 22,6 7,3 16,6
8 9,8 23,7 6,4 14,1
9 5,5 11,5
∑ 149,5 102,1 100,0
A B C ∑
n 9 8 7 24
R 149,5 102,1 100
R2/n 2483,36 1303,05 1428,57 5214,98
T = 12*5214,98/[24(24+1)]-3(24+1) = 29,3
χ2(1-α;k-1) = χ2(95%,2) = 5,99
Como T > χ2(95%,2), ou seja, 29,3 > 5,99, rejeita-se a hipótese de que as amostras possuem a mesma
distribuição de probabilidade com 95% de confiança.
Conclusão: as amostras possuem a mesma distribuição de probabilidade com 95% de confiança segundo o
teste de Kruskal-Wallis.
12.9 Questões
7. 1. Quais as propriedades matemáticas de uma fdp?

8. 2. Qual a importância das fdp na simulação?
9. 3. Que cuidados devem ser tomados ao usar fdp em simulação?
10. 4. Compare as distribuições de probabilidades apresentadas no texto.
11. 5. Quando usar e quando não usar as distribuições de probabilidades apresentadas no texto.
12. 6. Que condições devem ser seguidas ao aplicar distribuições de probabilidade?
13. 7. Relacione os parâmetros de fdp com os parâmetros de modelos de simulação. Faça um estude caso.
14. 8. Qual o significado matemático de E(x) e V(x). Como eles se relacionam com os parâmetros da fdp?
Como eles são calculados?
15. 9. Qual o significado de autocorrelação? Qual seu uso?
16. 10. Qual o significado estatístico das hipóteses H0 e Ha?
17. 11. Qual o significado gráfico das hipóteses H0 e Ha?
18. 12. Qual o significado matemático das hipóteses H0 e Ha?
19. 13. Quando se deve usar o teste CQ? Qual o procedimento para sua aplicação?
20. 14. O que é nível de significância? Qual sua importância prática? Qual seu significado gráfico?
21. 16. Relacione matematicamente o nível de significância com a hipótese H 0?

22. 17. Relacione graficamente o nível de significância com hipótese H 0?
23. 20. Dado o conjunto de valores {ai} estabeleça os passos necessários para verificar se estes dados se
ajustam a uma fdp qualquer utilizando o teste CQ.
24. 21. Qual o significado matemático de D no teste CQ?
25. 22. Qual o significado estatístico de D no teste CQ?
26. 23. Qual o significado gráfico de D no teste CQ?
27. 24. Qual a relação entre D, teste CQ, α e gl?
28. 25. Como se relacionam processo de chegada, filas, estatística, amostragem e simulação?
29. 26. Porque é necessário organizar dados em classes? Qual sua importância estatística? Qual sua
explicação matemática?
30. 27. Discuta as aplicações do teste de Kruskal-Wallis.
31. 28. Proponha outras maneiras de calcular o Rank do teste de Kruskal-Wallis.
32.
12.10 Exercícios
33. 1. Avaliar a normalidade dos dados referente aos ciclos de leitura de 15 unidades de memória pelos
testes CQ: X = {37 54,2 55,1 28,1 24 67,9 29,7 22,9 61,8 42,9 83,5 19,5 31,6 14 79,6}
34. 2. Seja avaliar a normalidade dos dados referente a medição de 10 execuções de um benchmark
utilizando o teste CQ: X = {1,9064 2,1029 1,5223 2,6183 1,4274 2,2249 1,6974 3,1544 1,9849 1,9957}
35. 3. Obtenha os parâmetros das fdp estudadas pelos métodos da máxima verossimilhança e mínimos
quadrados.
36. 4. Supondo a média de chegada de e-mail diários seja 100, qual a probabilidade de recebermos pelo
menos 50 e-mail num dia qualquer?
37. 5. Se pacotes numa rede chegam com taxa λ = 4 pps, qual a probabilidade de chegar 8 pacotes no
próximo segundo?
38. 6. A experiência indica que, em média, 20 clientes por hora param numa agência para acessar terminais
de computador.
a) Qual é a probabilidade de 10 clientes pararem a qualquer hora?

b) Qual é a probabilidade de 10 clientes ou menos pararem em qualquer hora?
c) Qual é o valor esperado, a média, e o desvio padrão para esta distribuição?
39. 7. Encontre a melhor fdp que se ajusta aos dados dos exercícios 1 e 2.
40. 8. Verifique se as amostras A, B e C são homogêneas, ou seja, possuem a mesma distribuição de
probabilidade.
A B C
70,2 76,5 66,7
92,8 101,2 88,2
18,6 20,3 17,7
96,1 104,8 91,3
53,4 58,2 50,8
2,0 2,1 1,9
15,9 17,4 15,1
35,1 38,3 33,4
96,4 105,1 91,6
40,9 44,6
97,7 106,5
49,8 54,3
62,3
41,4
4,2
41. 9. Foram medidos valores de λ e μ de um sistema que utiliza um Xbee Pro, abaixo relacionados.
λ(pps): 22 22 31 13 12 29 32 19 17 20 13 23 13 20 27 18 22 1 20 14 19 6 22 17 27 24
μ(pps): 33 44 13 19 28 24 35 36 34 27 14 30 23 17 23 5 20 39 37 35 23 34 22 28 42 27
a) Elimine os dados com valores extremos das séries λ e μ.

b) Verifique se as séries λ e μ são representativas da população.
c) Verifique se as séries λ e μ são independentes.

d) Faça os gráficos de barra das séries λ e μ e interprete-os.
e) Faça os gráficos box-plot das séries λ e μ e interprete-os.
f) Calcule os valores da média e desvio padrão das séries λ e μ.
g) Ajuste uma distribuição de probabilidade para a série λ por meio de testes de aderência.
h) Ajuste uma distribuição de probabilidade para a série μ por meio de testes de aderência.
42. 10. Faça os testes de CQ para os dados de λ e μ da série de dados abaixo considerando as fdp Beta,
Weibull, Gamma, Poisson e Exponencial.
λ(pps): 24 28 20 24 28 15 24 24 23 16 28 28 32 23 22 21 19 27 28 23 36 24
μ(pps): 19 14 18 9 29 9 25 17 30 19 12 15 9 22 22 31 19 12 12 16 30 2
43. 11. Faça os testes de CQ para os dados das séries de dados abaixo considerando as fdp Beta, Weibull,
Gamma e Normal.
a) λ(pps): 43 11 16 2 5 28 3 2 20 19 8 30 33 22 7 6 10 20 30 14 7 14 33 18 13 14 17 38 28
μ(pps): 7 12 16 19 5 15 18 10 25 14 19 16 7 7 12 13 17 4 15 16 19 20 2 21 19 16
b) λ(pps): 30 33 27 6 37 15 1 27 15 17 19 19 5 15 18 10 25 16 19 20 2 21 19
μ(pps): 9 22 22 31 19 12 12 16 30 14 33 18 13 14 17 8 30 33 22 7 6
13 RECURSOS DO C++ PARA A SIMULAÇÃO
A Linguagem ANSI C++11 implementou a biblioteca <random> e ampliou

consideravelmente sua capacidade de Gerar Números Aleatórios e também de Gerar
Variáveis Aleatórias, a saber (Brown, 2013; cppreference, 2013).
Quanto aos GNA, temos:
• Linear congruential engines: minstd_rand0, minstd_rand

• Mersenne twister engines: mt19937, mt19937_64
• Subtract with carry engines: ranlux24_base, ranlux48_base
• Discard block engines: ranlux24, ranlux48
• Shuffle order engine: knuth_b
Um exemplo de código C++11 é apresentado no Algoritmo 13.1 utilizando o Gerador

Mersenne Twister 64 b:
Algoritmo 13.1 Código em C++ 11 utilizando o Gerador Mersenne Twister 64 b

#include <random>
#include <iostream>
#include <stdio.h>
#include <time.h>
double u( double a, double b ){

static mt19937_64 eng(time(nullptr));
static uniform_real_distribution<double> uniform_real(a,b);
return uniform_real(eng);
}
int main( void ){

cout << "Distribuicao Uniforme: ";
for( int i = 0; i < 10; i++ )
cout << u(0.0,1.0) << " ";
cout << endl;
return 0;
}
Outro exemplo de código é apresentado no Algoritmo 13.2 utilizando o Gerador Mersenne

Twister 32 b:
Algoritmo 13.2 Código em C++ 11 utilizando o Gerador Mersenne Twister 32 b

#include <random>
#include <iostream>

int main( void ){
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<> dis(1,6);
for( int n = 0; n < 100; ++n )
cout << dis(gen) << ' ';
return 0;
}
Quanto a GVA, temos:
• Grupo Uniforme: uniform_int_distribution, uniform_real_distribution, generate_canonical

• Grupo Bernoulli: vbernoulli_distribution, binomial_distribution, negative_binomial_distribution,
geometric_distribution
• Grupo Poisson: poisson_distribution, exponential_distribution, gamma_distribution, weibull_distribution,
extreme_value_distribution
• Grupo Normal: normal_distribution, lognormal_distribution, chi_squared_distribution, cauchy_distribution,
fisher_f_distribution, student_t_distribution
Exemplo 13.1 Elabore um programa C++ para gerar VA com distribuição uniforme usando GNA Mersenne
Twister 32 b.
Algoritmo 13.3 Programa para gerar variáveis aleatórias com distribuição uniforme em C+
+11
#include <random>
#include <iostream>
int main( void ){
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<> dis(1, 6);
for( int n = 0; n < 10; ++n )
cout << dis(gen) << ' ';
cout << '\n';
return 0;
}
fonte: <http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution>
Exemplo 13.2 Elabore uma função C++ para gerar VA com distribuição exponencial, com parâmetro p = 0.5,
usando GNA GCL minstd_rand
Algoritmo 13.4 Função C++11 para gerar VA com distribuição exponencial, usando GNA GCL minstd_rand
#include <random>
#include <iostream>
double X( double p ){
static random_device rd;
static minstd_rand gna(rd());
exponential_distribution<> gva(p);
return gva(gna);
}
int main( void ){
double p = 0.5;
for( int n = 0; n < 10; ++n )
cout << X(p) << endl;
cout << endl;
return 0;
}
14 REDUÇÃO DA VARIÂNCIA
A qualidade da estimativa é medida através da largura do intervalo de confiança (IC). Este

último depende da variância, do valor de t1-α,n-1 e do número de observações n.
Considerando m∓t 1−α ,n−1

√ V
n
em que m, t, α, n e V são a média amostral, o ponto crítico
da distribuição t-Student bicaudal, o nível de significância e a variância amostral,

respectivamente.
Mantendo a média e a variância inalteradas, pode-se diminuir o valor de IC aumentando o

valor de α (t1-α,n-1 diminui) e/ou aumentando o valor de n (t 1-α,n-1 e n-1/2 diminui). Observa-se
que, para n > 18, o valor combinando do nível de significância (α = 5%) e do tamanho da
amostra tende a diminuir o seu efeito sobre o IC, Figura 14.1.
Figura 14.1 Variação de t0,95;n-1/n1/2 em função de n, combinando o efeito do nível de

significância e do tamanho da amostra.
Seria oneroso diminuir um intervalo de confiança apenas aumentando n pois isto implica em
mais amostras além de, com isto, sujeitar-se a outros erros experimentais no processo.
As técnicas de redução de variância são métodos estatísticos sofisticados que são muito
delicados de manusear e aplicar. Mal aplicado, este tipo de técnica pode até mesmo produzir
o efeito oposto (Chen, 2015).
14.1 Números Aleatórios Comuns

Esta técnica é utilizado principalmente na comparação de dois sistemas semelhantes, o

cenário a seguir ilustra seu princípio. Seja comparar o tempo de permanência médio (D) de
duas filas A e B, ambas do tipo FIFO (Chen, 2015).
O método de números aleatórios comuns (MNAC) consiste em enviar o mesmo número de

pacotes para dois sistemas, a mesma sequência de pacotes de chegada para as duas filas,
com o mesmo tempo de serviço. Supondo que foram simulados n pacotes nestes sistemas, o
i-ésimo pacote de A produz uma estimativa para E[D] que é denotado por D i,A, similarmente
Di,B é a estimativa para E[D] do i-ésimo pacote de B.
Ao final destas N simulações, a média (D A) e a variância (s2A) da amostra A, são dadas pelas
fórmulas clássicas:
n
1
D A= ∑D
n i=1 i , A
14.1
n
1
s 2A = ∑
n−1 i=1
(Di , A −D A )2 14.2
Similarmente, as fórmulas para a amostra B que são DB e s2B:

n
1
D B= ∑ Di ,B 14.3
n i=1
n
1
2
sB = ∑
n−1 i=1
( D i , B −D B )
2
14.4
A comparação entre A e B consiste em calcular a diferença Δ=DA-DB, que é um estimador de

E[DA]-E[DB]. Como estas estimativas são variáveis aleatórias, Δ é também uma variável
aleatória. O método MNAC nos permite reduzir sua variância, ou seja:
Var [Δ]=Var [ D A ]+Var [ D B ]−2 Cov[ D A , D B ]
Cov[ x , y ]=∑ ( xi −m x )( y i −m y ) em que m x =(∑ x i )/n e m y =(∑ y i )/n
Com o MNAC as duas simulações são correlacionadas. Esta correlação é positiva pois um
aumento do tráfego levará a um aumento no número de pacotes, tanto para A quanto para B
e, assim, provoca um aumento no E[DA] e E[DB]. Assim, Var [Δ] é menor no caso das
simulações serem feitas com uma sequência comum do que no caso de simulações
independentes. A verdadeira diferença entre E[DA] e E[DB] é então melhor avaliado devido a
esta técnica.
14.2 Variáveis Antitéticas
Variáveis antitéticas é o mais simples e um dos principais métodos para a redução da

variância de uma estimativa. O princípio deste método para estimar E[X] de alguma variável
aleatória denotado por X consiste em usar duas amostras de X negativamente
correlacionados por construção.
Seja m1 uma estimativa de E[X1], obtida de uma sequência de observações X 1 geradas a

partir de uma sequência de variáveis aleatórias uniforme U(0,1), {u i} i = 1, …, n.
Seja m2 uma segunda estimativa de E[X2], obtida de uma sequência de observações X 2

geradas a partir de uma sequência de variáveis aleatórias uniforme complementar {v i = 1-
ui} i = 1, …, n.
Estas duas sequências, {u} e {v} estão negativamente correlacionados. Tem-se duas
variáveis aleatória, m1 e m2, definindo m = (m1+m2)/2. É claro que m = E[X] e a variância de
m é dada por:
Var [ X 1 ]+Var [ X 2 ]+2 Cov [ X 1 , X 2 ] Var ( X )+Cov[ X 1 , X 2 ]

Var [m]= =
4 2
Em que Var(X) = Var[X1] = Var[X2].
Como m1 e m2 são, por construção, negativamente correlacionados, a variância seria

reduzida (Chen, 2015).
Exemplo 14.1 O algoritmo baixo foi feito para simular o método de números aleatórios comuns. Foram criados
dois sistemas de fila SF1 e SF2, cada um deles com N = 5000 pacotes, l = 300.0 pps e m = 400.0 pps. Foram
gerados dois números aleatórios para SF1, u1 e u2; u1 usada para gerar intervalos de chegada e u2 para gerar
tempos de serviço. Os valores de 1-u1 e 1-u2 para usados por SF2 para gerar intervalos de chegada e tempos
de serviço, respectivamente.
Os sistemas SF1 e SF2 foram simulados 1000 vezes e calculadas a Utilização e as Variâncias de tsf e nf.
Os resultados são apresentados nos gráficos abaixo: U x r, V(tsf) x r e V(nf) x r.
Pode-se observar nestes gráficos uma grande flutuação nos resultados, entretanto o uso de variáveis antitéticas
não resultou em redução da variância.
Figura 14.2 Variação da utilização do sistema SF1 U1 e do sistema SF2 U2 em função das
repetições r.
Figura 14.3 Variação do tempo total no sistema do sistema SF1 V1(tsf) e do sistema SF2
V2(tsf) em função das repetições r.
Figura 14.4 Variação do tamanho da fila do sistema SF1 V1(nf) e do sistema SF2 V2(nf) em
função das repetições r.
Conclusão: o uso de variáveis antitéticas não apresentou redução da variância neste estudo de caso.
//-------------------------------------------------------------------------------
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <algorithm>
#include <fstream>
#include <sstream>
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
class clPacote{
public:
int nf;
double ic, ts, cpf, eps, sps;
};
class clSF{
private:
double l, m, E[6], V[6];
double X ( double, double );

void Nf ( void );
public:
void Iniciar ( double, double );
void Empacotar ( double, double );
void Estatistica( void );
string Valor ( void );
};
double gna( void ){
return (rand()+1.0)/(RAND_MAX+2.0); // u in (0,1)
}
double clSF::X( double u, double p ){
return -log(u)/p;
}
void clSF::Iniciar( double l, double m ){
this->l = l;
this->m = m;
Pacote.clear();
Pacote.push_back({0,0,0,0,0,0}); // p = 0, primeiro pacote
}
void clSF::Empacotar( double u1, double u2 ){
clPacote P, Pa = Pacote[Pacote.size()-1];
P.ic = X(u1,l);
P.ts = X(u2,m);
P.sps = P.eps + P .ts;
Pacote.push_back(P);
}
void clSF::Nf( void ){
for( size_t p = 1; p < Pacote.size(); p++ ){
int c = p-1;
Pacote[p].nf = 0;
while( Pacote[p].cpf < Pacote[c].sps ){
Pacote[p].nf += 1;
c--;
}
}
}
void clSF::Estatistica( void ){
int N = Pacote.size();
double Sx[6]={0,0,0,0,0,0}, Sxx[6]={0,0,0,0,0,0};
Nf();
for( int p = 0; p < N; p++ ){
double x;
clPacote P = Pacote[p];
x = P.ic; Sx[0] += x; Sxx[0] += x*x;
x = P.ts; Sx[1] += x; Sxx[1] += x*x;
x = P.eps-P.cpf; Sx[2] += x; Sxx[2] += x*x; // tf
x = P.sps-P.eps; Sx[3] += x; Sxx[3] += x*x; // tps
x = P.sps-P.cpf; Sx[4] += x; Sxx[4] += x*x; // tsf
x = P.nf; Sx[5] += x; Sxx[5] += x*x;
}
for( int e = 0; e < 6; e++ ){
E [e] = Sx[e]/N;
V [e] = Sxx[e]/N-E[e]*E[e];
}
}
string clSF::Valor( void ){
double T = Pacote[N-1].sps, U = E[3]*N/T; // tps => 3
stringstream str;
str << V[4] << ";" << V[5] << ";" << U; // V(tsf), V(nf), U
return str.str();
}
void Salvar( string fn, string str ){
ofstream fs;
fs.open(fn);
replace(str.begin(), str.end(),'.',',');
fs << str;
fs.close();
}
int main( void ){
int N = 5000;
double l = 300.0,
m = 400.0;
clSF SF1, SF2;
stringstream csv;
csv << "r;V1(tsf);V1(nf);U1;V2(tsf);V2(nf);U2" << endl;
for( int r = 0; r < 1000; r++ ){
SF1.Iniciar(l,m);
SF2.Iniciar(l,m);
for( int i = 1; i < N; i++ ){
double u1 = gna(),
u2 = gna();
SF1.Empacotar(u1,u2);
SF2.Empacotar(1.0-u1,1.0-u2);
}
SF1.Estatistica();
SF2.Estatistica();
csv << r << ";" << SF1.Valor() << ";" << SF2.Valor() << endl;
}
Salvar("gna.nac-V-1000.out.csv", csv.str() );
return 0;
}
14.3 Métodos Estatísticos para Comparar Resultados

Simulados
A maioria dos projetos de análise de desempenho exigem comparar dois ou mais sistemas e
encontrar o melhor entre eles. A presente discussão, no entanto, será limitada a uma
comparação de apenas dois sistemas de cargas de trabalho muito semelhantes. Se houver
mais do que dois sistemas ou se os volumes de trabalho são significativamente diferentes, a
análise técnicas destes projetos experimental está além do escopo deste texto. O
procedimento para número de observações pareadas e não pareadas são diferentes. Estes
termos e os procedimentos correspondentes estão descritos a seguir iniciando com o teste
para média zero.
14.3.1 Teste para Média Zero
Um uso comum de intervalos de confiança é para verificar se um valor medido é

significativamente diferente de zero. Ao comparar uma medição aleatória com zero, as
instruções têm de ser feitas probabilisticamente, isto é, a um nível desejado de confiança. Se
o valor medido passa no teste de diferença, com uma probabilidade maior ou igual ao nível
de confiança especificado, 100(1-α)%, então o valor é significativamente diferente de zero.
O ensaio consiste na determinação de um intervalo de confiança e simplesmente verificar se

o intervalo inclui zero, isto é, intercepta o eixo X. As quatro possibilidades são mostradas na
Figura 14.5, onde IC é usado como uma abreviação para intervalo de confiança. O IC é
mostrado por uma linha vertical vermelha que se estende entre os limites de confiança
inferiores e superiores. A média da amostra é indicado por um círculo azul. Nos casos (a) e
(b), o intervalo de confiança inclui o zero, e, por conseguinte, os valores de medição não são
significativamente diferentes de zero. Nos casos em (c) e (d), o intervalo de confiança não
inclui o zero, e, por conseguinte, o valor medido é significativamente diferente de zero.
Figura 14.5 Teste para uma média zero, nos casos (a) e (b) os IC incluem zero e nos casos (c)
e (d) os IC não incluem zero.
Exemplo 14.2 A diferença entre os tempos de processamento de duas diferentes implementações do mesmo
algoritmo foi medida em sete cargas de trabalho semelhantes. As diferenças entre elas são: {1,5 2,6 -1,8 1,3 -
0,5 1,7 2,4}. Podemos dizer com confiança de 99% que uma aplicação é melhor do que a outra?
Tamanho da amostra: n = 7
Média: 7,20/7 = 1,03
Variância da amostra: 2,57
Desvio padrão da amostra: 2.571/2= 1,60
Intervalo de confiança: 1,03∓t×1,60/71/2 = 1.03 ∓ 0.605 t
100(1-α) = 99, α = 0,01, t99;6 = 0,995
Do Anexo, o valor de t com seis graus de liberdade é t0,995;6 = 3,707 (bicaudal).
O intervalo de confiança com 99% = (-4,9;7,0).
O intervalo de confiança inclui o zero. Portanto, não podemos dizer com confiança de 99% que existem
diferenças entre as aplicações.
14.3.2 Observações Pareadas
Se conduzir n experimentos em dois sistemas A e B de tal forma que exista uma

correspondência de um para um entre a amostra de ordem i do sistema A a amostra de
ordem i do sistema B, as observações são chamados pareadas. Por exemplo, se x i e yi
representam o desempenho da i-ésima carga de trabalho, as observações são chamados
emparelhadas. Se não há correspondência entre as duas amostras, as observações são
chamadas não pareadas.
A análise de observações pareadas é simples. As duas amostras são tratadas como uma
única amostra de n pares. Para cada par, a diferença no desempenho é calculada. Um
intervalo de confiança pode ser construída para a diferença. Se o intervalo de confiança inclui
o zero, os sistemas não são significativamente diferentes.
Tabela 14.1 Procedimento para comparar duas amostras pareadas (mesmo tamanho)
Dadas duas amostras x e y, calcular z = x-y.
√ √
x y
Vz Vz
x1 x1 Se 0∈(m z −t 1−α , n−1 , m z +t 1−α ,n−1 ) então não há diferença
n n
x2 y2
x3 y3 estatística entre as duas amostras, estatisticamente elas não são
... ...
diferentes. Caso contrário são diferentes.
xn-1 yn-1
n n
xn yn 1 1
Em que m z = ∑ z i e V z= ∑ 2
( zi −m z )
n i=1 n−1 i=1
Exemplo 14.3 Seis cargas de trabalho semelhantes foram utilizados em dois sistemas. As observações são
{5,36 16,57 0,62 1,41 0,64 7,26} e {19,12 3,52 3,38 2,50 3,60 1,74}. Um sistema é melhor do que o outro?
Número de observações: n = 6 (amostras pareadas)

Diferenças entre as amostras: {-13,7 13,1 -2,8 -1,1 -3,0 5,6}.
Média: -0,32
Variância da amostra: 81,62
Desvio padrão da amostra: 9,03
Intervalo de confiança: -0,32 ∓ t(81,62/6)1/2=-0,32 ∓ 3,69 t
O 0,95 quantil de uma variável t com cinco graus de liberdade é 2,571 (bicaudal)
IC com intervalo de confiança de 95%: -0,32 ∓ (2,571)(3,69)=(-9,80;9,16)
O intervalo de confiança inclui o zero. Portanto, os dois sistemas não são diferentes.
14.3.3 Observações não Pareadas
Dadas duas amostras A e B de tamanhos na e nb, respectivamente. As observações são não

pareadas no sentido em que não há correspondência entre os valores das amostras. Os
passos para determinar o intervalo de confiança para a diferença entre as médias das duas
amostras requer fazer a estimativa da variância e do número efetivo de graus de liberdade
de cada amostra.
Tabela 14.2 Procedimento para comparar duas amostras não pareadas (tamanhos diferentes)
Calcular:
n m
1 1
1. m x = ∑ x i e m y = ∑ yi
n i=1 m i=1
n m
1 1
x y
2. V x= ∑
n−1 i=1
2
( xi −m x ) e V y = ∑
m−1 i=1
( y i −m y )
2
x1 y1
x2
x3
...
y2
y3
...
3. d m=mx −m y e s=
√ Vx Vy
+
n m
2
xn-1 ...
Vx Vy
( + )
n m
xn ... 4. k=
ym-1
Vx 2 Vy 2
( ) ( )
ym n m
+
n−1 m−1
Se 0∈(d m −t 1−α ,k s ,d m +t 1−α ,k s) então não há diferença estatística
entre as duas amostras, estatisticamente elas não são diferentes. Caso
contrário são diferentes.
Se o intervalo de confiança inclui o zero, a diferença não é significativa a 100(1-α)% de

confiança. Se o intervalo de confiança não inclui o zero, então o sinal da diferença média
indica qual o sistema é melhor.
Exemplo 14.4 O tempo de processamento requerido para executar um pacote foi medido em dois sistemas. O
tempo no sistema A foi {5,36 16,57 0,62 1,41 0,64 7,26 1,74}. Os tempos no sistema B foram {19,12 3,52 3,38
2,50 3,60}. Os dois sistemas são significativamente diferentes?
Amostras não pareadas: na = 7, nb = 5

Para o sistema A: ma = 4,8, Va = 33,4, na = 7
Para o sistema B: mb = 6,4, Vb = 50,6, nb = 5
A diferença entre as médias: dm = -1,6
Desvio padrão das duas amostras: s = 3,8
Número efetivo de graus de liberdade: k = 7
0,95 quantil da variável t, com 7 graus de liberdade: t0,95;7 = 2,365 (bicaudal)
Intervalo de confiança de 95% para a diferença de médias = (-10,6;7,4)
O intervalo de confiança inclui o zero. Portanto, a este nível de confiança os dois sistemas não são diferentes.
14.4 Questões
1. Como os métodos RI e ML tratam os transientes?

2. Qual a utilidade de combinar os métodos RI e remoção de transientes?

3. Qual a utilidade de combinar os métodos ML e remoção de transientes?
14.5 Exercícios
1. Foram realizadas 4 rodadas de simulação, cada uma com 10 pacotes. Os dados de E[nf], E[tps] e p0 estão
listados abaixo. Calcule:
a) Intervalo de Confiança da média (μ) de E[nf], E[tps] e U para α = 10%, α = 5% e α = 1%.

b) Intervalo de Confiança da variância (σ2) de E[nf], E[tps] e p0 para α = 10%, α = 5% e α = 1%.
E[nf]
i/j 1 2 3 4 5 6 7 8 9 10
1 4 3 2 2 3 3 3 4 3 2
2 7 5 4 5 5 4 4 7 4 4
3 12 18 7 2 8 8 6 9 10 6
4 20 3 13 5 4 12 9 7 8 9
E[tps]
i/j 1 2 3 4 5 6 7 8 9 10
1 1.83 1.83 1.83 1.71 1.83 1.98 1.86 1.83 1.71 1.74
2 2.13 2.04 2.01 2.16 2.13 1.86 2.07 2.07 1.98 2.07
3 2.40 2.52 2.4 2.34 2.34 2.31 2.46 2.25 2.46 2.40
4 2.64 2.94 2.58 2.88 2.70 2.55 2.85 2.55 2.79 2.58
p0
i/j 1 2 3 4 5 6 7 8 9 10
1 0.373 0.346 0.385 0.374 0.362 0.347 0.397 0.340 0.408 0.475
2 0.256 0.252 0.341 0.264 0.275 0.355 0.330 0.231 0.322 0.374
3 0.181 0.108 0.200 0.171 0.216 0.230 0.197 0.195 0.149 0.278
4 0.116 0.008 0.165 0.033 0.022 0.134 0.078 0.116 0.031 0.190
2. Foi realizada uma rodada de simulação com 300 pacotes de tempo total no sistema, abaixo relacionados.
Calcule o Intervalo de Confiança da média (μ) de s para α = 10%, α = 5% e α = 1%.
p tsf p tsf p tsf p tsf p tsf p tsf

1 0,404 51 4,476 101 0,018 151 0,016 201 0,017 251 1,321
2 1,955 52 0,017 102 3,169 152 3,266 202 0,408 252 0,716
3 0,271 53 0,015 103 1,342 153 0,720 203 1,203 253 0,017
4 0,829 54 1,373 104 0,362 154 0,309 204 0,018 254 0,378
5 0,499 55 1,720 105 0,961 155 0,013 205 0,036 255 6,478
6 0,208 56 2,215 106 0,225 156 1,066 206 1,989 256 0,164
7 2,173 57 0,281 107 0,548 157 0,012 207 0,205 257 0,212
8 2,431 58 0,432 108 0,017 158 0,898 208 0,101 258 0,057
9 2,904 59 0,059 109 0,301 159 0,067 209 0,012 259 1,737
10 0,033 60 0,391 110 3,862 160 0,189 210 2,285 260 0,820
11 3,395 61 0,011 111 0,090 161 0,037 211 0,913 261 6,078
12 0,026 62 0,123 112 5,624 162 1,260 212 0,259 262 0,097
13 0,127 63 0,160 113 1,156 163 0,092 213 0,554 263 0,126
14 0,059 64 2,769 114 0,044 164 0,009 214 0,090 264 0,137
15 0,098 65 2,005 115 0,082 165 0,038 215 0,045 265 0,778
16 2,198 66 1,549 116 1,832 166 1,421 216 3,903 266 0,491
17 0,024 67 0,030 117 0,018 167 0,075 217 0,037 267 0,029
18 0,010 68 0,058 118 0,018 168 0,051 218 0,014 268 0,446
19 0,130 69 0,015 119 0,729 169 0,042 219 0,891 269 0,960
20 0,300 70 0,016 120 0,049 170 0,362 220 0,114 270 0,101
21 0,145 71 0,053 121 0,132 171 0,809 221 0,332 271 0,056
22 0,792 72 0,136 122 0,456 172 0,015 222 0,245 272 2,138
23 0,019 73 2,812 123 0,112 173 0,046 223 0,236 273 3,339
24 5,175 74 4,056 124 0,112 174 5,506 224 0,094 274 1,143
25 0,038 75 0,010 125 0,390 175 3,050 225 2,759 275 0,017
26 0,256 76 0,883 126 0,014 176 3,730 226 0,475 276 6,556
27 1,411 77 1,156 127 0,602 177 0,559 227 6,327 277 0,026
28 0,023 78 0,074 128 2,128 178 0,010 228 0,010 278 0,336
29 0,155 79 4,526 129 1,431 179 2,912 229 3,210 279 1,251
30 0,195 80 0,026 130 1,960 180 0,143 230 0,081 280 1,006
31 4,262 81 0,088 131 0,764 181 0,359 231 0,061 281 3,183
32 1,030 82 0,010 132 5,004 182 6,021 232 0,052 282 0,091
33 3,494 83 0,053 133 0,093 183 0,236 233 0,582 283 0,036
34 3,851 84 0,014 134 0,430 184 0,009 234 0,016 284 0,917
35 0,285 85 4,128 135 1,163 185 0,128 235 0,013 285 0,013
36 5,334 86 0,190 136 2,220 186 0,055 236 0,537 286 0,026
37 0,110 87 0,092 137 1,041 187 1,142 237 0,018 287 0,410
38 0,023 88 0,081 138 0,011 188 0,023 238 5,487 288 0,009
39 0,747 89 0,352 139 2,125 189 2,876 239 0,018 289 0,126
40 2,567 90 0,901 140 0,014 190 0,055 240 2,864 290 0,022
41 0,100 91 3,335 141 4,777 191 2,458 241 3,516 291 0,009
42 2,170 92 3,692 142 6,056 192 0,429 242 4,778 292 0,016
43 0,186 93 0,129 143 0,081 193 0,016 243 5,460 293 0,057
44 2,922 94 0,033 144 0,418 194 5,417 244 1,292 294 0,022
45 1,588 95 0,016 145 0,146 195 0,126 245 0,507 295 0,422
46 0,049 96 0,010 146 0,526 196 0,223 246 4,404 296 2,829
47 0,492 97 1,631 147 0,365 197 0,468 247 0,035 297 0,364
48 1,356 98 0,304 148 0,021 198 0,230 248 0,115 298 0,020
49 0,353 99 0,775 149 0,052 199 0,022 249 0,029 299 0,028
50 0,400 100 0,045 150 0,252 200 0,125 250 0,804 300 0,242
3. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de simulação, cada uma
com M eventos e calcule os Intervalos de Confiança da média (μ) e da variância (σ2) de nf, tf, tps e tsf
para α = 10%, α = 5% e α = 1% nos casos:
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000

5. Modifique o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar B rodadas de simulação, cada
uma com M eventos e calcule os Intervalos de Confiança da média (μ) e da variância (σ 2) de p0 para α =
10%, α = 5% e α = 1% nos casos:
a) B = 10 e M = 2000
b) B = 10 e M = 4000
c) B = 10 e M = 6000

7. Utilize o software SF.MM1-ML-RI.cpp descrito no Anexo para realizar rodadas de simulação com N eventos
e calcule os Intervalos de Confiança da média (μ) e da variância (σ 2) de iat, st, nq, p0, w e r para α =
10%, α = 5% e α = 1% nos casos:
a) N = 1000
b) N = 10000
c) N = 100000

15 SOFTWARES PARA SIMULAÇÃO SISTEMAS DE FILA
Os Softwares para Simulação Sistemas de Fila são fornecidos gratuitamente no estado em

que se encontra. Use-os por sua conta e risco. Não me responsáveis pelas ações de nenhum
dos usuários destes softwares. Também não me responsabilizo por quaisquer danos causados
pelo uso destes softwares. Finalmente, é responsabilidade do leitor seguir os padrões
apropriados de integridade acadêmica.
15.1 Dicionário de Dados dos Softwares
Tabela 15.1 Dicionário de Dados dos algoritmos
Nome44 Descrição
B Tamanho de bloco dos métodos ML e RI
clPacote Classe com as variáveis de estado de pacotes da simulação
clRSF Classe com as variáveis de estado de Rede de Sistemas de Fila M/M/1
clSF Classe com as variáveis de estado de Sistemas de Fila M/M/1
cpf Tempo no qual o pacote chega na Fila [s]
eps Tempo no qual o pacote chega no Servidor [s]
DP Vetor de valores de desvio padrão
DP(x) Desvio padrão de x
E Vetor de valores de esperança matemática (média aritmética)
E(x) Média aritmética de x
Empacotar Método para calcular o estado de cada pacote e incluí-lo em Pacote
Estatistica Método para calcular as médias e desvios padrão da simulação
ic Intervalo entre chegadas de pacotes na Fila [s -1]
Iniciar Método para configurar os Sistemas de Fila e gerar o pacote zero (0)
is Intervalo entre saídas de pacotes do Servidor [s -1]
L Número de lotes do MML
l, λ Taxa de chegada de pacotes na Fila [s]
Legenda Método para criar a legenda do software
m Vetor de taxa de serviço de Servidores de RSF [s]
m, μ Taxa de serviço do Servidor [s]
ML Método que implementa o método da Média de Lotes (MML)
N Número inicial de simulações dos Sistemas de Fila
nf Tamanho da Fila
Nf Método para calcular o tamanho da Fila dos pacotes simulados
44 O termo pacote será adotado neste texto para indicar as unidades operacionais dos Sistemas de Fila; são sinônimos de pacote os ter-
mos tarefa, transação, trabalho, instrução, flops e operação, dentre outras denominações encontradas na literatura da área.
P Percentagem do total de pacotes utilizados no MRI

p Ordem dos pacotes, o primeiro pacote tem ordem zero (0)
p Parâmetro da distribuição de probabilidade Exponencial
P, Pa Instância de clPacote
Pacote Vetor de clPacote
Pi, Pf Pacotes inicial e final (MML e MRI)
r Vetor de rota de pacotes na RSF
R Número de repetições do MRI
RI Método que implementa o método de Repetições Independentes (MRI)
RSF Rede de Sistemas de Fila M/M/1
SF Vetor de Sistemas de Fila M/M/1
Simular Método para simular todos os pacotes
Resumo Método para criar tabela resumida com os valores simulados
T Duração da simulação [s]
Tabela Método para criar tabela com os valores simulados
tf Tempo de espera na Fila [s]
sps Tempo no qual o pacote sai do Servidor [s]
ts Tempo de serviço do Servidor para processar um pacote [s -1]
tsf Tempo total no Sistema de Fila [s]
u Variável aleatória com distribuição de probabilidade Uniforme
U Utilização do Servidor
X Método para calcular variável aleatória
Tabela 15.2- Dicionário de Funções e Constantes da Biblioteca Padrão C/C++

Nome Descrição
srand Obtém a semente (valor inicial) do gerador de números (pseudo)aleatórios
time Obtém e retorna o tempo decorrido desde 01/01/1970 00:00:00 em segundos
nullptr Ponteiro nulo
rand Gera um número (pseudo)aleatório na faixa entre 0 e RAND_MAX
RAND_MAX Constante inteira definida no arquivo stdlib.h
15.2 SF.MM1.cpp
Algoritmo 15.1 Software SF.MM1 para simulação de Sistema de Fila M/M/1

//-------------------------------------------------------------------------------
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
class clPacote{
public:
int nf;
double ic, cpf, eps, sps;
};
class clSF{
private:
double l, m, E[3], DP[3];
void Empacotar ( void );
void Nf ( void );
string Tabela ( void );

string Legenda ( void );
public:
clSF ( void );
string Resumo ( void );
};
clSF::clSF( void ){
}
return -log(u)/p;
}
this->l = l;
this->m = m;
Pacote.clear();
Pacote.push_back({0,0,0,0,0});
}
void clSF::Empacotar( void ){
int p;
clPacote P, Pa;
p = Pacote.size()-1;
Pa = Pacote[p];
P.ic = X(l);
P.sps = P.eps + X(m);
P.nf = 0;
}
void clSF::Simular( int N ){
for( int p = 1; p < N; p++ ){
Empacotar();
}
Nf();
Estatistica();
}
size_t c = p-1;
Pacote[p].nf = 0;
Pacote[p].nf = Pacote[p].nf + 1;
c--;
}
}
}
void clSF::Estatistica( void ){
double Sx[3]={0,0,0}, Sxx[3]={0,0,0};
for( int p = 0; p < N; p++ ){
double x;
x = P.eps-P.cpf; Sx[0] += x; Sxx[0] += x*x;
x = P.sps-P.eps; Sx[1] += x; Sxx[1] += x*x;
x = P.nf; Sx[2] += x; Sxx[2] += x*x;
}
for( int e = 0; e < 3; e++ ){
E [e] = Sx[e]/N;
DP[e] = sqrt( Sxx[e]/N-E[e]*E[e] );
}
}
string clSF::Tabela( void ){
stringstream htm;
htm << fixed;
htm.precision(5);
htm << "Simulacao de Sistemas de Fila M/M/1 Metodo 1<hr>"
<< "Eventos do SF<hr>"
<< "<table border='1'>"
<< "<tr><th>p<th>ic<th>cpf<th>eps<th>sps<th>nf";
htm << "<tr>"
<< "<td>" << p+1
<< "<td>" << P.ic
<< "<td>" << P.cpf
<< "<td>" << P.eps
<< "<td>" << P.sps

<< "<td>" << P.nf;
}
htm << "</table><br><br><br>";
return htm.str();
}
string clSF::Resumo( void ){
double T = Pacote[N-1].sps,
U = E[1]*N/T;
stringstream htm;
htm << "<html>"

<< "<style>table{font-family: Helvetica, Arial; font-size: 22px; background-color:
#f7e8d9}</style>"
<< "<body>"
<< "<div style='font-family: Helvetica, Arial; font-size: 25px; background-color: #d6e7f8'>";
htm << fixed;
htm.precision(3);
htm << Tabela();
htm << "<br><br><br>"
<< "Resumo dos Indicadores do SF<hr>"
<< "<table>"
<< "<tr><td> l <td>=<td>" << l
<< "<tr><td> m <td>=<td>" << m
<< "<tr><td> N <td>=<td>" << N
<< "<tr><td> T <td>=<td>" << T
<< "<tr><td> E (tsf) <td>=<td>" << E [0]+E [1]
<< "<tr><td> E (nf) <td>=<td>" << E [2]
<< "<tr><td> DP(tsf) <td>=<td>" << DP[0]+DP[1]
<< "<tr><td> DP(nf) <td>=<td>" << DP[2]
<< "<tr><td> U <td>=<td>" << U
<< "</table><br><br><br>";
htm << Legenda();
htm << "</div></body></html>";
return htm.str();
}
string clSF::Legenda( void ){
stringstream htm;
htm << "Legenda Metodo 1<hr>"
<< "<table border='1' cellpadding='3'>"
<< "<tr><th>Variável<th>Descrição <th>Unidade"
<< "<tr><td>B <td>tamanho do bloco do ML <td>[p] "
<< "<tr><td>cpf <td>chegada de pacote na Fila <td>[s] "
<< "<tr><td>DP(x)<td>desvio padrão de x <td> "
<< "<tr><td>eps <td>entrada de pacote no Servidor <td>[s] "
<< "<tr><td>E(x) <td>média aritmética de x <td> "
<< "<tr><td>ic <td>intervalo entre chegadas de pacotes na Fila <td>[s/p]"
<< "<tr><td>is <td>intervalo entre saídas de pacotes do Servidor <td>[s/p]"
<< "<tr><td>L <td>número de blocos do ML <td>[p] "
<< "<tr><td>l <td>taxa de chegada de pacotes na Fila <td>[p/s]"
<< "<tr><td>ML <td>método da Média de Lotes <td> "
<< "<tr><td>m <td>taxa de serviço do Servidor <td>[p/s]"
<< "<tr><td>m <td>vetor taxa de serviço <td>[p/s]"
<< "<tr><td>nf <td>número de pacotes da Fila <td>[p] "
<< "<tr><td>N <td>número de pacotes simulados <td>[p] "
<< "<tr><td>p0 <td>probabilidade de Servidor ocioso <td>[] "
<< "<tr><td>p <td>ordem dos pacotes <td>[p] "
<< "<tr><td>P <td>tamanho do bloco do RI <td>[%] "
<< "<tr><td>RI <td>método das Repetições Independente <td> "
<< "<tr><td>RSF <td>Rede de Sistema de Fila <td> "
<< "<tr><td>R <td>número de repetições do RI <td>[p] "
<< "<tr><td>r <td>rota de pacotes <td>[] "
<< "<tr><td>SF <td>Sistema de Fila <td> "
<< "<tr><td>sps <td>saída de pacote do Servidor <td>[s] "
<< "<tr><td>tf <td>tempo de espera de pacotes na Fila <td>[s] "
<< "<tr><td>tsf <td>tempo de processamento de pacotes no Sistema de Fila <td>[s] "
<< "<tr><td>ts <td>tempo de processamento de pacotes no Servidor <td>[s] "
<< "<tr><td>T <td>duração da Simulação <td>[s] "
<< "<tr><td>U <td>utilização do Servidor <td>[] "
return htm.str();
}
ofstream fs;
fs.open(fn);
fs << str;
fs.close();
}
int main( void ){
int N = 5000;
double l = 283.3,
m = 305.7;
clSF SF;
SF.Iniciar(l,m);
SF.Simular(N);
Salvar("M1.SF.MM1.out.html", SF.Resumo() );
return 0;
}
15.3 SF.MM1-ML-RI.cpp
Algoritmo 15.2 Software SF.MM1 para simulação de Sistema de Fila M/M/1 com os Métodos
Média de Lotes e Replicações Independentes
//-------------------------------------------------------------------------------
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
class clPacote{
public:
int nf;
double ic, cpf, cps, sps;
};
class clSF{
private:
double l, m, E[3];
void Empacotar ( void );
void Nf ( void );
void Estatistica( int, int );
void Salvar ( string, string );
public:
clSF( void );
void ML ( double, double, int, int );
void RI ( double, double, int, int, int );
};
clSF::clSF( void ){
}
return -log(u)/p;
}
this->l = l;
this->m = m;
Pacote.clear();
Pacote.push_back({0,0,0,0,0});
}
void clSF::Empacotar( void ){
int p;
clPacote P, Pa;
p = Pacote.size()-1;
Pa = Pacote[p];
P.ic = X(l);
P.cps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
P.sps = P.cps + X(m);
P.nf = 0;
}
void clSF::Simular( int N ){
for( int p = 1; p < N; p++ ){
Empacotar();
}
Nf();
}
size_t c = p-1;
Pacote[p].nf = 0;
Pacote[p].nf = Pacote[p].nf + 1;
c--;
}
}
}
void clSF::Estatistica( int Pi, int Pf ){
double Sx[3] = {0,0,0};
for( int p = Pi; p < Pf; p++ ){
Sx[0] += P.cps-P.cpf;
Sx[1] += P.sps-P.cps;
Sx[2] += P.nf;
}
for( int e = 0; e < 3; e++ )
E[e] = Sx[e]/(Pf-Pi);
}
string clSF::Legenda( void ){
stringstream htm;
return htm.str();
}
void clSF::Salvar( string fn, string str ){
ofstream fs;
fs.open(fn);
fs << str;
fs.close();
}
void clSF::ML( double l, double m, int B, int K ){
int N = B*K;
stringstream htm;
htm << fixed;
htm.precision(2);
htm << "<html>"
<< "<style>body {font-family: Helvetica, Arial; font-size: 22px; background-color: #d6e7f8}"
<< " table{font-family: Helvetica, Arial; font-size: 22px; background-color:
#a1b2c3}</style>"
<< "<body><br><br><br>"
<< "<br> Simulacao de Sistema de Fila M/M/1 Modelo 1"
<< "<br> Media de Lotes<hr>"
<< "<br> l = " << l
<< "<br> m = " << m
<< "<br> N = " << N
<< "<br> B = " << B
<< "<br> K = " << K
<< "<br><br>"
<< "<tr><th>B<th>Pi<th>Pf<th>T<th>E[tsf]<th>E[nf]<th>U";
Iniciar(l,m);
Simular(N);
htm.precision(5);
for( int b = 0; b < B; b++ ){
int Pi = b*K, Pf = (b+1)*K;
Estatistica(Pi,Pf);
double T = Pacote[Pf-1].sps-Pacote[Pi].cps,
U = E[1]*(Pf-Pi)/T;
cout << "SF ML - Lote " << b+1 << " Pi = " << Pi << " Pf = " << Pf-1 << endl;
htm << "<tr>"
<< "<td>" << b+1
<< "<td>" << Pi
<< "<td>" << Pf-1
<< "<td>" << T
<< "<td>" << E[0]+E[1]
<< "<td>" << E[2]
<< "<td>" << U;
}
htm << Legenda();
htm << "</body></html>";
Salvar("M1.SF.MM1.ML.out.html", htm.str() );
}
void clSF::RI( double l, double m, int N, int R, int P ){
int Pi = (1-P/100.0)*N, Pf = N;
stringstream htm;
htm << fixed;
htm.precision(2);
htm << "<html>"
#a1b2c3}</style>"
<< "<br> Simulacao de Sistema de Fila M/M/1 Metodo 1"
<< "<br> Repeticoes Independentes<hr>"
<< "<br> l = " << l
<< "<br> m = " << m
<< "<br> N = " << N
<< "<br> R = " << R
<< "<br> Pi = " << Pi
<< "<br> Pf = " << Pf
<< "<br><br>"
<< "<tr><th>R<th>Pi<th>Pf<th>T<th>E[tsf]<th>E[nf]<th>U";
htm.precision(3);
for( int r = 0; r < R; r++ ){
cout << "SF RI - Repeticao " << r+1 << " Pi = " << Pi << " Pf = " << Pf-1 << endl;
Iniciar(l,m);
Simular(N);
Estatistica(Pi,Pf);
double T = Pacote[Pf-1].sps-Pacote[Pi].cps,
U = E[1]*(Pf-Pi)/T;
htm << "<tr>"
<< "<td>" << r+1
<< "<td>" << Pi
<< "<td>" << Pf-1
<< "<td>" << T
<< "<td>" << E[0]+E[1]
<< "<td>" << E[2]
<< "<td>" << U;
}
htm << Legenda();
Salvar("M1.SF.MM1.RI.out.html", htm.str() );
}
int main( void ){
int N = 5000,
B = 10, // ML numero de lotes
K = 500, // ML tamanho do lote
R = 10, // RI repeticoes
P = 10; // RI percentagem final
double l = 500.0,
m = 750.0;
clSF SF;
SF.ML(l,m,B,K);
SF.RI(l,m,N,R,P);
return 0;
}
15.4 RSF.MM1.cpp
Algoritmo 15.3 Software RSF.MM1 para simulação de Rede de Sistemas de Fila M/M/1
//------------------------------------------------------------------------------
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
class clPacote{
public:
int nf;
double ic, cpf, eps, sps, is;
};
class clSF{
public:
double l, m, E[3], DP[3];
};
class clRSF{
private:
vector<int> r;
vector<clSF> SF;
void Empacotar ( int );
void Nf ( void );
string Tabela ( int );
public:
clRSF ( void );
string Resumo ( void );
void Salvar ( string, string );
};
clRSF::clRSF( void ){
}
return -log(u)/p;
}
this->r = r;
SF.clear();
for( size_t sf = 0; sf < m.size(); sf++ ){
clSF X;
X.l = l;
X.m = m[sf];
X.Pacote.clear();
SF.push_back(X);
}
SF[r[i]].Pacote.push_back({0,0,0,0,0,0});
}
size_t p, sf;
clPacote P, Pa;
if( i > 0 ){
sf = r[i-1];
p = SF[sf].Pacote.size()-1;
Pa = SF[sf].Pacote[p];
P.ic = Pa.is;
}
else P.ic = X( SF[0].l );
sf = r[i];
P.sps = P.eps + X( SF[r[i]].m );
P.nf = 0;
SF[sf].Pacote.push_back(P);
}
for( int p = 1; p < N; p++ ){
for( size_t i = 0; i < r.size(); i++ ){
Empacotar(i);
}
}
Nf();
Estatistica();
}
for( size_t sf = 0; sf < SF.size(); sf++ ){
for( size_t p = 1; p < SF[sf].Pacote.size(); p++ ){
size_t c = p-1;
SF[sf].Pacote[p].nf = 0;
while( SF[sf].Pacote[p].cpf < SF[sf].Pacote[c].sps ){
SF[sf].Pacote[p].nf = SF[sf].Pacote[p].nf + 1;
c--;
}
}
}
}
void clRSF::Estatistica( void ){
size_t N = SF[sf].Pacote.size();
double Sx [3] = {0,0,0},
Sxx[3] = {0,0,0};
for( size_t p = 0; p < N; p++ ){
double x;
clPacote P = SF[sf].Pacote[p];
x = P.eps-P.cpf; Sx[0] += x; Sxx[0] += x*x;
x = P.sps-P.eps; Sx[1] += x; Sxx[1] += x*x;
x = P.nf; Sx[2] += x; Sxx[2] += x*x;
}
for( int e = 0; e < 3; e++ ){
double md = Sx[e]/N;
SF[sf].E [e] = md;
SF[sf].DP[e] = sqrt( Sxx[e]/N - md*md );
}
}
}
string clRSF::Tabela( int sf ){
stringstream htm;
htm << fixed;
htm.precision(5);
htm << "<br> Tabela de Eventos do SF: " << sf
<< "<br><table border='1' cellpadding='1'>"
<< "<tr><th>SF<th>p<th>ic<th>cpf<th>eps<th>sps<th>nf<th>is";
htm << "<tr>"
<< "<td>" << sf
<< "<td>" << p
<< "<td>" << P.ic
<< "<td>" << P.cpf
<< "<td>" << P.eps
<< "<td>" << P.sps
<< "<td>" << P.nf
<< "<td>" << P.is;
}
htm << "</table>";

return htm.str();
}
string clRSF::Resumo( void ){
stringstream htm;
htm << fixed;
htm.precision(1);
htm << "<html>"
#a1b2c3}</style>"
<< "Simulacao de Rede de Sistemas de Fila M/M/1 Metodo 1"
<< "<br>RSF Tabela Metodo 1"
<< "<br>Numero de SF:" << SF.size()
<< "<br>Sequencia:";
htm << r[i-1] << "-" << r[i] << ";";
htm << "</table>"
<< "<br><br><br>"
<< "<tr><th>RSF<th>l<th>m<th>N";
htm << "<tr><td>0<td>" << SF[0].l << "<td>" << SF[0].m << "<td>" << SF[0].Pacote.size();
for( size_t sf = 1; sf < SF.size(); sf++ )
htm << "<tr><td>" << sf << "<td>-<td>" << SF[sf].m << "<td>" << SF[sf].Pacote.size();
htm << "</table>";

htm << "<br><br><br>";
for( size_t sf = 0; sf < SF.size(); sf++ ) htm << Tabela(sf);
htm << "<br><br><br>"
<< "Resumo dos Indicadores da RSF Metodo 1"
<< "<tr><th>SF<th>N<th>T<th>E[tsf]<th>E[nf]<th>DP[tsf]<th>DP[nf]<th>U";
htm.precision(3);
int N = SF[sf].Pacote.size();
double T = SF[sf].Pacote[N-1].sps,
U = SF[sf].E[1]*N/T;
htm << "<tr>"
<< "<td>" << sf
<< "<td>" << N
<< "<td>" << T
<< "<td>" << SF[sf].E [0]+SF[sf].E [1]
<< "<td>" << SF[sf].E [2]
<< "<td>" << SF[sf].DP[0]+SF[sf].DP[1]
<< "<td>" << SF[sf].DP[2]
<< "<td>" << U;
}
htm << Legenda();
return htm.str();
}
string clRSF::Legenda( void ){
stringstream htm;

return htm.str();
}
void clRSF::Salvar( string fn, string str ){
ofstream fs;
fs.open(fn);
fs << str;
fs.close();
}
int main( void ){
int N = 50;
vector<int> r = { 0, 1, 2, 1, 3, 1, 4, 1, 2, 1, 0 };
double l = 1200;
vector<double> m = { 1000, 1000, 1000, 1000, 1000 };
clRSF RSF;
RSF.Iniciar(l,m,r);
RSF.Simular(N);
RSF.Salvar( "M1.RSF.MM1.out.html", RSF.Resumo() );
return 0;
}
15.5 RSF.MM1-ML-RI.cpp
Algoritmo 15.4 Software RSF.MM1 para simulação de Rede de Sistemas de Fila Software
SF.MM1 com os Métodos Média de Lotes e Replicações Independentes
//------------------------------------------------------------------------------
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
class clPacote{
public:
int nf;
double ic, cpf, cps, sps, is;
};
class clSF{
public:
double l, m, E[3];
};
class clRSF{
private:
vector<int> r;
void Nf ( void );
public:
vector<clSF> SF;
clRSF();
void Estatistica( int, int, int );
};
clRSF::clRSF(){
}
return -log(u)/p;
}
this->r = r;
SF.clear();
clSF X;
X.l = l;
X.m = m[sf];
X.Pacote.clear();
SF.push_back(X);
}
SF[r[i]].Pacote.push_back({0,0,0,0,0,0});
}
size_t p, sf;
clPacote P, Pa;
if( i > 0 ){
sf = r[i-1];
P.ic = Pa.is;
}
else P.ic = X(SF[0].l);
sf = r[i];
P.cps = P.cpf > Pa.sps ? P.cpf : Pa.sps;
P.sps = P.cps + X(SF[sf].m);
P.nf = 0;
SF[sf].Pacote.push_back(P);
}
for( int p = 1; p < N; p++ )
Empacotar(i);
Nf();
}
size_t c = p-1;
SF[sf].Pacote[p].nf = 0;
while( SF[sf].Pacote[p].cpf < SF[sf].Pacote[c].sps ){
SF[sf].Pacote[p].nf += 1;
c--;
}
}
}
}
void clRSF::Estatistica( int sf, int Pi, int Pf ){
double Sx[3] = {0,0,0};
for( int p = Pi; p < Pf; p++ ){
Sx[0] += P.sps-P.cps; // 0-ts
Sx[1] += P.sps-P.cpf; // 1-tsf
Sx[2] += P.nf; // 2-nf
}
for( int e = 0; e < 3; e++ ){
SF[sf].E[e] = Sx[e]/(Pf-Pi);
}
}
string clRSF::Legenda( void ){
stringstream htm;
htm << "Legenda<hr>"
<< "<table>"
<< "<tr><td> l <td>=<td> taxa de chegada de pacotes na Fila"
<< "<tr><td> m <td>=<td> taxa de servico do Servidor"
<< "<tr><td> N <td>=<td> numero de pacotes simulados"
<< "<tr><td> T <td>=<td> duracao da simulacao"
<< "<tr><td> p <td>=<td> ordem dos pacotes"
<< "<tr><td> ic <td>=<td> intervalo entre chegadas de pacotes na Fila"
<< "<tr><td> cpf <td>=<td> tempo de chegada de pacote na Fila"
<< "<tr><td> cps <td>=<td> tempo de chegada de pacote no Servidor"

<< "<tr><td> sps <td>=<td> tempo de saida de pacote do Servidor"
<< "<tr><td> tf <td>=<td> tempo de espera na Fila"
<< "<tr><td> ts <td>=<td> tempo de permanecia no Servidor"
<< "<tr><td> tsf <td>=<td> tempo total no Sistema de Fila"
<< "<tr><td> nf <td>=<td> comprimento da Fila"
<< "<tr><td> is <td>=<td> intervalo entre saidas de pacotes do Servidor"
<< "<tr><td> E(x)<td>=<td> media aritmetica de x"
<< "<tr><td> U <td>=<td> utilizacao do Servidor"
<< "</table>"
<< "<br><br><br>";
return htm.str();
}
ofstream fs;
fs.open(fn);
fs << str;
fs.close();
}
void ML( double l, vector<double> m, vector<int> r, int N, int L ){
stringstream htm;
htm << fixed;
htm.precision(7);
htm << "<html><body>"
<< "<br> Rede de Sistemas de Fila M/M/1"
<< "<br> Media de Lotes <hr>"
<< "<br> N = " << N
<< "<br> L = " << L
<< "<br>Numero de SF:" << m.size()
htm << r[i-1] << "-" << r[i] << ";";
htm << "</table>"
<< "<br><br>"
<< "<tr><td>SF<td>l<td>m";
htm << "<tr><td>" << s;
if( s == 0) htm << "<td>" << l;
else htm << "<td>-";
htm << "<td>" << m[s];
}
htm << "</table>"
<< "<br><br>"
<< "<td>SF<td>L<td>Pi<td>Pf<td>T<td>E[tsf]<td>E[nf]<td>U";
clRSF RSF;
RSF.Iniciar(l,m,r);
RSF.Simular(N);
int B = RSF.SF[sf].Pacote.size()/L;
for( int i = 0; i < L; i++ ){
int Pi = i*B, Pf = (i+1)*B;
cout << " RSF ML - Lote " << sf << " " << i << " Pi = " << Pi << " Pf = " << Pf-1 << endl;
RSF.Estatistica(sf,Pi,Pf);
double T = RSF.SF[sf].Pacote[Pf-1].sps-RSF.SF[sf].Pacote[Pi].cps,
U = RSF.SF[sf].E[0]*(Pf-Pi)/T;
htm << "<tr>"
<< "<td>" << sf
<< "<td>" << i+1
<< "<td>" << Pi
<< "<td>" << Pf-1
<< "<td>" << T
<< "<td>" << RSF.SF[sf].E[1]
<< "<td>" << RSF.SF[sf].E[2]
<< "<td>" << U;
}
htm << endl;
}
htm << RSF.Legenda();
htm << "</html>";
Salvar("RSF.MM1.ML.out.html", htm.str() );
}
void RI( double l, vector<double> m, vector<int> r, int N, int R, int P ){
clRSF RSF;
stringstream htm;
htm << fixed;
htm.precision(7);
htm << "<html><body>"
<< "<br> Rede de Sistemas de Fila M/M/1"

<< "<br> Repeticoes Independentes <hr>"
<< "<br> N = " << N
<< "<br> R = " << R
<< "<br> P = " << P << "%"
<< "<br>Numero de SF:" << m.size()
htm << r[i-1] << "-" << r[i] << ";";
htm << "</table>"
<< "<br><br>"
<< "<tr><td>SF<td>l<td>m";
htm << "<tr><td>" << s;
if( s == 0 ) htm << "<td>" << l;
else htm << "<td>-";
htm << "<td>" << m[s];
}
htm << "</table>"
<< "<br><br>"
<< "<td>SF<td>R<td>Pi<td>Pf<td>T<td>E[tsf]<td>E[nf]<td>U";
for( int i = 1; i <= R; i++ ){
RSF.Iniciar(l,m,r);
RSF.Simular(N);

int Pf = RSF.SF[sf].Pacote.size(),
Pi = (1-P/100.0)*Pf;
cout << " RSF RI - repeticao " << sf << " " << i
<< " Pi = " << Pi << " Pf = " << Pf << endl;
RSF.Estatistica(sf,Pi,Pf);
double T = RSF.SF[sf].Pacote[Pf-1].sps-RSF.SF[sf].Pacote[Pi].cps,
U = RSF.SF[sf].E[0]*(Pf-Pi)/T;
htm << "<tr>"
<< "<td>" << sf
<< "<td>" << i
<< "<td>" << Pi
<< "<td>" << Pf-1
<< "<td>" << T
<< "<td>" << RSF.SF[sf].E[1]
<< "<td>" << RSF.SF[sf].E[2]
<< "<td>" << U;
}
htm << endl;
}
htm << RSF.Legenda();
htm << "</html>";
Salvar("RSF.MM1.RI.out.html", htm.str() );
}
int main( void ){
int N = 5000;
vector<int> r = { 0, 1, 2, 1, 3, 1, 4, 1, 2, 1, 0 };
double l = 1388;
vector<double> m = { 1812, 2250, 7500, 4000, 20000 };
int L = 10, // ML numero de lotes

R = 10, // RI repeticoes
P = 10; // RI percentagem final
ML(l,m,r,N,L);
RI(l,m,r,N,R,P);
return 0;
}
16 MODELO ANALÍTICO DE SISTEMAS DE FILA M/M/1
(incompleto)
Uma vez que a soma de todas probabilidades deve ser igual a 1, tem-se a seguinte
expressão para a probabilidade de zero pacote na Fila do sistema:
p0=1−ρ 16.1
Demonstração:
∞ ∞ ∞
1 1 1
∑ pi=1 ⇒ ∑ p 0 ρi=1⇒ p0 ∑ ρi=1 ⇒ p0 = ∞ = ∞ = ρ =1−ρ
i=0 i=0 i=0
∑ ρi 1+ ∑ ρi 1+
1−ρ
i=0 i=1
∞
x
Nota: ∑ x =
n
,|x|<1 , soma da progressão geométrica infinita (Polyanin & Manzhirov, 2007, pag. 357).
n=1 1−x
Substituindo p0 em pn, obtém-se:
pn=(1−ρ)ρn 16.2
Pode-se derivar a partir de pn, as propriedades das filas M/M/1 que foram apresentadas na
Erro: Origem da referência não encontrada. Por exemplo, a Utilização do Servidor é dada pela
probabilidade de se ter uma ou mais pacotes no sistema:
U=1−p 0=ρ 16.3
O número médio de pacotes no sistema é dado por:
∞ ∞
ρ
E[n]=∑ n pn=∑ n(1−ρ) ρn= 16.4
n=1 n=1 1−ρ
Demonstração (Mor, 2013, p. 145):

∞
ρ
d∑ρ
n
n d( )
∞ ∞
dρ ∞
1−ρ ρ
∑ n (1−ρ)ρn =(1−ρ)∑ nρn=(1−ρ) ∑ ρ d ρ =(1−ρ)ρ n=1
dρ
=(1−ρ)ρ
dρ
=
1−ρ
n=1 n=1 n=1
Jain (1991) apresenta uma demostração baseada no Processo Nascimento Morte que é muito mais
interessante.
A variância do número de pacotes no sistema é

∞
ρ
V [n]=E[n ]−( E[n]) =∑ n (1−ρ)ρ −( E [n]) =
2 2 2 n 2
2 16.5
n =1 (1−ρ)
A probabilidade de n ou mais pacotes no sistema é
∞
P(k ≥n)=∑ (1−ρ) ρ =ρ
k n
16.6
k=n
O tempo médio de resposta pode ser calculado usando a Lei de Little, que estabelece que
número médio de tarefas no sistema=taxade chegada×tempo médio de resposta 16.7

isto é
E[ n] ρ 1
E[n]=λ E [r ]⇔ E [r ]= ⇔ E[r ]= ⇔ E[r ]= 16.8
λ (1−ρ) λ (1−ρ)μ
A função de distribuição acumulada (FDA) do tempo de resposta é

F(r)=1−e−μ(1−ρ)r 16.9
Note-se que o tempo de resposta é distribuído exponencialmente. A partir da qual pode-se
calcular seus percentis. Por exemplo, o q-percentil do tempo de resposta pode ser calculado
por
q −μ (1−ρ)r q 1 100
F(r q )= ⇔1−e =q
⇔r q = ln ( ) 16.10
100 100 μ (1−ρ) 100−q
Da mesma forma, a FDA do tempo de espera é dado por
F(w)=1−ρ e−μ(1−ρ)w 16.11
Trata-se de uma distribuição exponencial truncada. Seu q-percentil é dado por
1 100ρ
w q= ln ( ) 16.12
μ (1−ρ) 100−q
Esta fórmula se aplica somente se q é maior do que 100(1-ρ) sendo os demais percentis não
nulos. Isto pode ser indicado pela equação:
E [w] 16.13
w q=max {0 , ρ ln(10 ρ)}
O número médio de pacotes na Fila é dado por
∞ ∞ 2
ρ
E[nq ]=∑ (n−1) p n=∑ (n−1)(1−ρ)ρ =
n
16.14
n=1 n=1 1−ρ
17 GVA PELO MÉTODO DA INVERSA
Uma grande desvantagem do Método da Inversa aplicado na Geração de Variáveis Aleatórias

é que seu uso esta limitado a distribuições que possuem FDA inversível como, por exemplo,
as distribuições Exponencial, Logística e Pareto, Gumbel ou Valores Extremos e Weibull. A
Tabela 17.1 lista estas distribuições de probabilidade, suas fdp, fda e x, a técnica de GVA
destas fda, onde u ~ U(0,1).
Tabela 17.1 Distribuições de probabilidade, fdp, fda e x, a técnica de GVA destas fda, onde u
~ U(0,1).
1
1 2 x−m 1
4s 2s 1+exp [−( )] u
s
1 a 1 1 1
1
Pareto ( ) (1− a−1 ) [ ] a−1
x a−1 x 1−u (a−1)
s s s s
a x a−1 x a x a 1
Weibull ( ) exp[−( ) ] 1−exp [−( ) ] b[−ln(u)]a
b b b b
Nos tópicos abaixo estão descritos os procedimentos matemáticos para Gerar Variáveis
Aleatórias das fdp Exponencial, Logística e Pareto, Gumbel ou Valores Extremos e Weibull,
listadas na Tabela 17.1.
17.1 GVA da Distribuição de Probabilidade Exponencial
Uma variável aleatória x segue a distribuição de probabilidade Exponencial se sua função

densidade de probabilidade é dada pela equação f ( x)=λ exp(−λ x) , com x ≥ 0 e λ > 0.
A função de distribuição acumulada da distribuição Exponencial é dada por:

x
1
F( x )=∫ λ exp(−λ x)=1−exp(−λ x)
0 s
Fazendo F(x) = u, onde u ~ U(0,1), obtem-se:
u=1−exp(−λ x) ⇔ exp(−λ x)=1−u ⇔ −λ x=ln(1−u) ⇔ x=−ln (1−u)/λ .
Como (1-u) ~ U(0,1) e u ~ U(0,1) são intercambiáveis, tem-se que x=−ln (u)/λ .
Conclusão: x=−ln(u)/λ uma variável aleatória com distribuição de probabilidade

Exponencial, f ( x)=λ exp(−λ x) de parâmetro λ, usando números aleatórios u com distribuição
uniforme, u ~ U(0,1).
17.2 GVA da Distribuição de Probabilidade de Valores

Extremos
Uma variável aleatória x segue a distribuição de probabilidade de Valores Extremos se sua

função densidade de probabilidade é dada pela equação:
1 x−m x−m
f (x)= exp [− −exp (− )] , x, m, s ∊ ℝ, com s > 0; m é o parâmetro de localização e s
s s s
é o parâmetro de escala.
A função de distribuição acumulada da distribuição de de Valores Extremos é dada por:

x
1 x −m x−m x−m
F( x )= ∫ exp[ −exp( )]dx=exp [−exp(− )]
−∞ s s s s
x−m x−m x−m

u=exp[−exp(− )] ⇔ ln (u)=−exp(− ) ⇔ ln[−ln (u)]=− ⇔ x=m−s ln [−ln(u)] .
s s s
Conclusão: x=m−s ln [−ln (u)] uma variável aleatória com distribuição de probabilidade de
1 x−m x−m
Valores Extremos, f (x)= exp [− −exp (− )] e parâmetros m e s, usando números
s s s
aleatórios u com distribuição uniforme, u ~ U(0,1).
17.3 GVA da Distribuição de Probabilidade Logística
Uma variável aleatória x segue a distribuição de probabilidade Logística se sua função

densidade de probabilidade é dada pela equação:
1 x−m
f (x)= sech2 ( ) , x, m, s ∊ ℝ, com s >0; m é o parâmetro de localização e s é o
4s 2s
parâmetro de escala.
A função de distribuição acumulada da distribuição de Pareto é dada por:

x
1 2 x−m 1
F( x )= ∫ sech ( ) dx=
−∞ 4s 2s x−m
1+exp [−( )]
s
1 x−m 1 x−m 1 x−m 1

u= ⇔ 1+exp[−( )]= ⇔ exp[−( )]= −1 ⇔ −( )=ln ( −1) ⇔
x −m s u s u s u
1+exp [−( )]
s
1
x=m−s ln ( −1) .
u
1
Conclusão: x=m−s ln ( −1) uma variável aleatória com distribuição de probabilidade
u
1 2 x−m
Logística, f (x)= sech ( ) de parâmetros m e s, usando números aleatórios u com
4s 2s
distribuição uniforme, u ~ U(0,1).
17.4 GVA da Distribuição de Probabilidade de Pareto
Uma variável aleatória x segue a distribuição de probabilidade de Pareto se sua função

1 a
densidade de probabilidade é dada pela equação f (x)=( ) definida para x ≥ 1. Onde a > 1
x
é um parâmetro de forma, que é conhecido como índice de cauda.
A função de distribuição acumulada da distribuição de Pareto é dada por:

x a
1 1 1
F( x )=∫ ( ) dx= (1− a −1 )
1 x a−1 x
1 1 1 1 a−1 1
u= (1− a−1 ) ⇔ u(a−1)=1− a−1 ⇔ a−1 =1−u (a−1) ⇔ x = ⇔
a−1 x x x 1−u( a−1)
1
1
x=[ ] a−1 .
1−u(a−1)
1
1
Conclusão: x=[ ] a−1 é uma variável aleatória com distribuição de probabilidade de
1−u(a−1)
a
1
Pareto, f ( x)=( ) de parâmetros a, usando números aleatórios u com distribuição uniforme,
x
u ~ U(0,1).
17.5 GVA da Distribuição de Probabilidade Weibull
Uma variável aleatória x segue a distribuição de probabilidade Weibull se sua função

a x a−1 x a
densidade de probabilidade é dada pela equação f (x)= ( ) exp [−( ) ] definida para x ≥ 0.
b b b
Onde o parâmetro a ≥ 0 é adimensional, o parâmetro de forma, variações no valor de a
alteram drasticamente o comportamento da distribuição. O parâmetro b ≥ 0 é medido na
mesma unidade que x, e está associado à escala do gráfico da função, ou seja, variações no
seu valor, enquanto k é mantido constante, causam a compressão ou expansão do gráfico.
A função de distribuição acumulada da distribuição de Weibull é dada por:

x
a x a−1 x a x a
F( x )=∫ ( ) exp [−( ) ]dx=1−exp [−( ) ]
0 b b b b

a a a
x x x x
u=1−exp[−( ) ] ⇔ 1−u=exp[−( ) ] ⇔ ln (1−u)=−( )
b b b
⇔ √a −ln (1−u)= b ⇔ x=b √ −ln( 1−u) .
a
x=b √ −ln ( u) .
a
Como (1-u) ~ U(0,1) e u ~ U(0,1) intercambiáveis, tem-se que
Conclusão: x=b √ −ln (u) é uma variável aleatória com distribuição de probabilidade Weibull
a
a−1 a
a x x
f (x)= ( ) exp [−( ) ] , de parâmetros a e b, usando números aleatórios u com distribuição
b b b
uniforme, u ~ U(0,1).
18 REFERÊNCIAS
Averill, M. L. Simulation Modeling and Analysis. Pearson Education, 2006.
Bandyopadhyay, Susmita; Bhattacharya, Ranjan. Discrete and Continuous Simulation: Theory

and Practice. CRC Press, 2014. 344p.
Brown, Walter E. Random Number Generation in C++11. 2013. Disponível em:

<http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3551.pdf>. Acesso em: 20 Dez
2013.
Bussab, W. O.; Morettin, P. A. Estatística Básica. 5ed. São Paulo: Saraiva, 2002. 526p.
Catalunha, Márcio José; Sediyama, Gilberto Chohaku; Leal, Brauliro Gonçalves; Soares, Carlos
Pedro Boechat; Ribeiro, Aristides. Aplicação de cinco funções densidade de probabilidade a
séries de precipitação pluvial no Estado de Minas Gerais. Revista Brasileira de
Agrometeorologia, v. 10, n. 01, p. 153-162, 2002.
Chen, Ken. Performance Evaluation by Simulation and Analysis with Applications to Computer
Networks. John Wiley & Sons, 2015. 226p.
Chung, Christopher A. Simulation modeling handbook: a practical approach. Boca Raton,

Florida: CRC Press LLC, 2004. 574p.
cppreference. Pseudo-random number generation. Disponível em:

<http://en.cppreference.com/w/cpp/numeric/random>. Acesso em: 20 Dez 2013.
Domo 8. Data Never Sleeps 8.0. Disponível em:

<https://www.domo.com/learn/infographic/data-never-sleeps-8>. Acesso em: 09 Dez 2021.
Domo 9. Data Never Sleeps 9.0. Disponível em:

<https://www.domo.com/learn/infographic/data-never-sleeps-9>. Acesso em: 09 Dez 2021.
Epperson, James F. An introduction to numerical methods and analysis. 2 nd ed. Hoboken, New
Jersey: John Wiley & Sons, Inc., 2013. 591p.
Forbes, Catherine; Evans, Merran; Hastings, Nicholas; Peacock, Brian. Statistical distributions.
4th ed. Hoboken, New Jersey: John Wiley & Sons, Inc., 2011. 212p.
Freitas Filho, Paulo José. Introdução à Modelagem e Simulação de Sistemas com Aplicações
Arena. 2a ed. Florianópolis: Visual Books, 2008. 372p.
Gentle, J. E. Handbook of Computational Statistics. Heidelberg: Springer, 2004. 900p.

(ISBN/ASIN: 3540404643, ISBN13: 9783540404644).
Hines, W. W. et al. Estatística Aplicada e Probabilidade para Engenheiros. LTC, 2003.
Hirata, Miguel, H. Uma introdução ao aproveitamento da energia eólica. Rio de Janeiro, Brazil:
Proceedings of ENCIT 2004, ABCM, 2004. Disponível em
<http://www.abcm.org.br/anais/encit/2004/artigos/invited/CIT04-IL14.pdf>. Acesso em: 19
Mai 2015.
Hull, T. E.; Dobell, A. R. Random Number Generators. SIAM Review, 1962, Vol. 4, No. 3: pp.
230-254. (Disponível em45: <https://www.jstor.org/stable/2027716>. Acesso em: 04 Set 2019.
Jain, R. The Art of Computer Systems Performance Analysis: Techniques for Experimental
Design, Measurement, Simulation, and Modeling. Wiley-Interscience, 1991.
Kroese, Dirk P.; Chan, Joshua C. C. Statistical Modeling and Computation. Springer: New York,
2014.
L'Ecuyer, Pierre. L'Ecuyer's Combined Recursive Generator, 2007. Disponível em:

<http://www.democritos.it/activities/IT-MC/ACML-4.0.1/L_0027Ecuyer_0027s-Combined-
Recursive-Generator.html>. Acesso em: 10 Mar 2011.
L'Ecuyer, Pierre. MRG32k3a.c. Disponível em:

<http://simul.iro.umontreal.ca/rng/MRG32k3a.c>. Acesso em: 24 Mar 2020.
Larson, Ron; Farber, Betsy. Estatística Aplicada. 4ed. São Paulo: Pearson Prentice Hall, 2010,
637p.
Leemis, Larry. Univariate Distribution Relationships. Disponível em:

<http://www.math.wm.edu/~leemis/chart/UDR/UDR.html>. Acesso em: 13 Mai 2015.
Leite, Maysa Lima; Virgens Filho, Jorim Sousa. Ajuste de modelos de distribuição de
probabilidade a séries horárias de velocidade do vento para o município de Ponta Grossa,
Estado do Paraná. Acta Scientiarum. Technology Maringá, v.33, n.4, p.447-455, 2011.
Marsaglia, George; Tsang, Wai Wan; Wang, Jingbo. Evaluating Kolmogorov’s Distribution.
Disponível em: <http://www.jstatsoft.org/v08/i18/paper?ev=pub_ext_btn_xdl>. Acesso em: 13
Mai 2015.
Mersenne Twister. What is Mersenne Twister (MT)?. Disponível em:

<http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ewhat-is-mt.html>. Acesso em: 10 Mar
2011.
Mor, Harchol-Balter. Performance modeling and design of computer systems: queueing theory
in action. Cambridge University Press, New York, 2013. 574p.
NIST. NIST Special Publication 800-22 Revision 1a: A Statistical Test Suite for Random and
Pseudorandom Number Generators for Cryptographic Applications. 2010. Disponível em:
<http://csrc.nist.gov/publications/nistpubs/800-22-rev1a/SP800-22rev1a.pdf>. Acesso em: 20
Mai 2016.
Polyanin, Andrei D.; Manzhirov, Alexander V. Handbook of Mathematics for Engineers and
Scientists. New York: Chapman & Hall/CRC, 2007. 1509p.
Ross, Sheldon M. Simulation. 5th ed. Elsevier: Amsterdam, 2013. 310p.
Spiegel, Murray R., Schiller, John J, Srinivasan, R. Alu. Probability and statistics. 4ed. New York:
McGraw-Hill, 2013. 424p.
Simard, Richard; L’Ecuyer, Pierre. Computing the Two-Sided Kolmogorov-Smirnov Distribution.

Disponível em: <http://www.iro.umontreal.ca/~lecuyer/myftp/papers/ksdist.pdf>. Acesso em:
04 Abr 2015.
45 <http://chagall.med.cornell.edu/BioinfoCourse/PDFs/Lecture4/random_number_generator.pdf>
Sun Microsystems. Sun Fire™ X4150, X4250, and X4450 Server Architecture. September
2008. Disponível: <https://docplayer.net/7413100-Sun-fire-x4150-x4250-and-x4450-server-
architecture-breakthrough-density-using-sun-and-intel-technology.html>. Acesso em: 22 Jul
2021.
Thom, H. C. S. A note on the gamma distribution. Monthly Weather Review, Washington, v.86,
p.117-122, 1958.
Zwillinger, Daniel; Kokoska, Stephen. Standard probability and statistics tables and formulary
- Student Edition. CRC Press: Boca Raton, 2000. 215p.
Fonte: https://image.flaticon.com/icons/png/512/47/47443.png
As fragatas são aves de grande porte, com asas compridas e estreitas que representam a menor
superfície de asa por unidade de peso do mundo das aves. Têm cerca de 1 metro de
comprimento, mais de dois de envergadura e uma cauda longa e bifurcada. As
fragatas não conseguem andar em terra, nadar nem levantar voo de uma superfície
plana. São, no entanto, aves extremamente rápidas em voo sobre o mar ou sobre
outras aves.

Modelagem e Simulação Discreta: Brauliro G Leal

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Modelagem e Simulação Discreta: Brauliro G Leal

Enviado por

Direitos autorais:

Formatos disponíveis

Versão 10/03/2022

Modelagem e Simulação Discreta

Atribuição-CompartilhaIgual – esta licença permite que outros remixem, adaptem e

Brauliro Gonçalves Leal

Professor do Colegiado de Engenharia da Computação

Sobre este documento

Este documento foi escrito em LibreOffice (www.libreoffice.org), suas imagens foram

Software livre é a melhor ideia!

Pois o conforto intelectual e o hábito têm horror das mensagens que

Edgar Morin (Le Monde: 20 de abril de 2020)

Modelagem e Simulação Discreta

Neste texto foram construídos os Modelos Analítico, Conceitual e Computacional de Sistemas

O Modelo Conceitual de Sistemas de Fila e seu respectivo Modelo Computacional, aqui

Os modelos computacionais foram implementados em C++, pelo rigor da linguagem, e em

Os algoritmos para a Geração de Variáveis Aleatórias também são contribuições relevantes,

Outros algoritmos foram desenvolvidos, destinados aos tópicos relevantes da Simulação de

Construindo a Modelagem e Simulação de Sistemas Computacionais

A seguir são relacionados os principais conceitos que dão suporte à modelagem e a

Os Sistemas Computacionais são transversais na vida das pessoas, das empresas e

Com sua concisão e ubiquidade, a matemática é a linguagem que permite escrever

A simulação discreta faz uso de variáveis aleatórias de modo a representar a grande

Visão dos Tópicos Tratados no Livro

A maioria das simulações estocásticas têm a mesma estrutura básica:

Figura 1 Esquema dos principais destaques do livro.

Para a simulação de um Sistema Computacional, o primeiro passo é a construção de um

Nome3 Descrição Unidade

7.4 Software SF.MM1-ML-RI.cpp..............................................................................................76

12.7 Gerando Processos de Chegada....................................................................................138

Os Sistemas Computacionais prestam relevantes serviços e compartilham recursos em vários

Devido a sua grande importância e alcance espaço-temporal, é necessário a avaliação destes

Para representar a diversidade dos Sistemas Computacionais são necessários variados

Os Sistemas de Filas são utilizados para a modelagem analítica, simulação e avaliação do

A Simulação de Sistemas Computacionais pode ser vista como o estudo do comportamento

O uso da Simulação Discreta pode oferecer vantagens quando é necessário estimar

A Simulação Discreta é um instrumento com grande potencial de aplicação comercial, na

recursos de sistemas multimídia, Computação em Nuvem, Internet das Coisas (IoT),

A seguir serão apresentados os conceitos de sistema, modelo e simulação, nesta ordem.

O mundo real é de elevada complexidade e de difícil acesso, a sua compreensão é analítica,

Figura 1.1 Representação gráfica da relação sistema e o mundo real.

Figura 1.2 Circuito integrado TTL 7400, um sistema do mundo computacional.

Os Sistemas de Fila são sistemas gerais e orientados, conforme apresentado abaixo.

Modelos são descrições de um sistema, concebidos através de uma abstração da realidade

A construção de um modelo, em geral, busca viabilizar a solução de um problema de um

A utilidade de um modelo está diretamente relacionada à sua capacidade de incorporar

Figura 1.3 Representação gráfica da relação mundo real, sistema e modelo.

Figura 1.4 Um modelo do circuito integrado TTL 7400.

O exemplo a seguir mostra o poder dos modelos.

Exemplo 1.4 Os 6 números que definem todo o Universo

Como estudamos o Universo como um todo?

Meu trabalho se concentra na radiação cósmica de fundo em micro-ondas (CMB, na sigla em

Mas há muitas outras maneiras de estudar o cosmos, e os físicos que o fazem se

Fazemos observações em quase todos os regimes de comprimento de ondas acessíveis para

As observações provêm de lugares próximos e dos confins mais distantes do espaço.

Todas essas evidências e teorias podem ser reunidas em um modelo padrão

O primeiro parâmetro descreve a quantidade de matéria normal, átomos, no Universo, e diz

O terceiro parâmetro é a constante cosmológica, a misteriosa energia escura que está na

1.3 Dinâmica Temporal de Sistemas Computacionais

Generalizando estas ideias, os Sistemas Computacionais recebem tarefas para serem

• Vazão ou Throughput: é o número de tarefas executados em um determinado intervalo de tempo.

A simulação permite reproduzir o comportamento dos sistemas, utilizando modelos de

Uma das grandes utilidades da simulação é tornar possível fazer estimativas do

O Método de Monte Carlo é um método estatístico que utiliza amostragens aleatórias

Trace ou Rastreio é um registro cronológico de eventos ocorridos em um sistema real, como