Este livro foi concebido como uma introdução à biblioteca Python SimPy (Simulation in Python) para construção de modelos de simulação de eventos discretos em Python. Ele é produto do trabalho de alguém que pesquisa, ensina e utiliza profissionalmente ferramentas de simulação no seu dia-a-dia.

Propositadamente, o livro é dividido em seções curtas, enfatizando um conceito por vez, facilitando o processo de aprendizado e a busca rápida por material de referência.

Antes de prosseguir, um pequeno aviso:

A obra pressupõe que o leitor possua conhecimentos de Modelagem e Simulação de Eventos Discretos, esteja fazendo algum curso sobre o assunto ou mesmo lendo o prestigioso livro Modelagem e Simulação de Eventos Discretos (Chwif & Medina).

Este livro, portanto, não se pretende como fonte de consulta sobre metodologias de modelagem de sistemas, mas sim, um livro sobre uma das linguagens mais fascinantes disponíveis para se construir modelos de simulação.

Ao caro leitor que inicia aqui sua navegação, uma sugestão: mentalize e reflita sobre um projeto de simulação que gostaria de desenvolver em SimPy e, a cada seção vencida do livro, tente desenvolver em paralelo o seu próprio projeto em harmonia com o conteúdo aprendido.

Un bon voyage!

Afonso C. Medina

Este livro foi elaborado a partir de seções compactadas em textos curtos, para que o leitor, a cada seção, tenha uma visão clara do conteúdo apresentado, construindo o conhecimento de maneira sólida e respeitando a sua curva de aprendizado pessoal.

SimPy (Simulation in Python) é um framework¹ para a construção de modelos de simulação de eventos discretos em Python e distribuído segundo a licença MIT. Ele se diferencia dos pacotes comerciais usualmente utilizados na simulação de eventos discretos, pois não se trata de uma aplicação com objetos prontos, facilmente conectáveis entre si por simples cliques do mouse. Com o SimPy, cabe ao usuário construir um programa de computador em Python que represente seu modelo. Essencialmente, SimPy é uma biblioteca de comandos que conferem ao Python o poder de construir modelos a eventos discretos.

Com o SimPy pode-se construir, além de modelos de simulação discreta, modelos de simulação em “Real Time”, modelos de agentes e até mesmo modelos de simulação contínua. De fato, e como o leitor notará ao longo deste texto, essas possibilidades estão mais associadas ao Python do que propriamente aos recursos fornecidos pelo SimPy.

Talvez a pergunta correta seja: “por que utilizar o Python?”

Python é hoje, talvez, a linguagem mais utilizada no meio científico e uma breve pesquisa pela Internet vai sugerir artigos, posts e intermináveis discussões sobre os porquês desse sucesso todo. Eu resumiria o sucesso do Python em 3 grandes razões:

• Facilidade de codificação. Engenheiros, matemáticos e pesquisadores em geral querem pensar no problema, nem tanto na linguagem e Python cumpre o que promete quando se fala em facilidade. Se ela é fácil de codificar, mais fácil ainda é ler e interpretar um código feito em Python;
• Bibliotecas! Bibliotecas! Um número inacreditável de bibliotecas (particularmente para a área científica) está disponível para o programador (e pesquisador).
• Scripts. A funcionalidade de trabalhar com scripts² ou pequenos trechos de código interpretado (basicamente, Python é uma linguagem script) diminui drasticamente o tempo de desenvolvimento e aprendizado da linguagem.

Além disso, o SimPy, quando comparado com pacotes comerciais, é gratuito - o que por si só é uma grande vantagem num mercado em que os softwares são precificados a partir de milhares de dólares - e bastante flexível, no sentido de que não é engessado apenas pelos módulos existentes.

Sob o aspecto funcional, SimPy se apresenta como uma biblioteca em Python e isso significa que um modelo de simulação desenvolvido com ele, terá à disposição tudo que existe de bom para quem programa em Python: o código fica fácil de ler (e desenvolver), o modelo pode ser distribuído como um pacote (sem a necessidade do usuário final instalar o Python para executá-lo), além das diversas bibliotecas de estatística e otimização disponíveis em Python, que ampliam, em muito, o horizonte de aplicação dos modelos.

Esta disponibilidade de bibliotecas, bem como ser um software livre, torna o SimPy particularmente interessante para quem está desenvolvendo sua pesquisa acadêmica na área de simulação. O seu modelo provavelmente ficará melhor documentado e portanto mais fácil de ser compreendido, potencializando a divulgação dos resultados de sua pesquisa em dissertações, congressos e artigos científicos.

Prós:

• Código aberto e livre (licença MIT);
• Diversas funções de bibliotecas de otimização, matemática e estatística podem ser incorporadas ao modelo;
• Permite a programação de lógicas sofisticadas, apoiando-se no Python (e suas bibliotecas);
• Comunidade ativa de desenvolvedores e usuários que mantém a biblioteca atualizada.

Contras:

• Desempenho: embora seja notável a melhora de desempenho do Python a cada nova versão, SimPy é uma biblioteca de simulação, isto é: ela pertence a uma classe de aplicações bastante exigente em termos computacionais. Assim, não conte com tempos de processamento comparáveis àqueles de pacotes comerciais, tais como o AnyLogic ou o Simul8, pois não será;
• Ausência de ferramentas para animação;
• Necessidade de se programar cada processo do modelo;
• Exige conhecimento prévio em Python;
• Não inclui um ambiente visual de desenvolvimento.

O SimPy surgiu em 2002 baseado na combinação das ideias do Simscript e da família de linguagens Simula. Contextualizando, ele combina o SiPy, pacote desenvolvido por Klaus Muller, baseado no Simula, com o SimPy, desenvolvido por Tony Vignaux and Chang Chui e baseado em outra linguagem, o Simscript. Talvez o que melhor simbolize a genênse do SimPy seja a decisão do Prof. Klaus Muller em utilizar geradores ou funções geradoras na construção do pacote. Quando os dois projetos originais foram unidos no SimPy como conhecemos hoje, o trio decidiu por seguir pelo caminho dos geradores, até então uma grata novidade no Python 2.2 (estamos ainda em 2002, pessoal!).

Começou sua infância sendo utilizado em cursos de introdução à simulação e, aos poucos foi despertando o interesse de pesquisadores e profissionais. A partir da versão 3.0, o SimPy, já contando com um número maior de desenvolvedores, foi totalmente reescrito e sua importância no mundo da simulação pode ser medida pela infinidade de trabalhos publicados em conferências e revistas especializadas, bem como na sua reimplementação em outras linguagem, tais como linguagens como a C# (Sim#), a Julia (ConcurrentSim) e o R (simmer).

Existe uma variedade de vídeos e tutoriais disponíveis na Internet, mas, quando procuro ajuda nos meus projetos, são três as fontes de consulta que mais utilizo:

• O próprio site do projeto http://simpy.readthedocs.io, com exemplos e uma detalhada descrição da da Interface de Programação de Aplicações (Application Programming Interface - API);
• A lista de discussão de usuários é bastante ativa, com respostas bem elaboradoras;
• O Stack Overflow tem um número razoável de questões e exemplos, mas cuidado pois boa parte do material ainda refere-se à antiga versão 2 do SimPy, bastante diferente da versão 3, base deste livro.

Este texto foi planejado em formato de seções compactas, de modo que sejam curtas e didáticas – tendo por meta que cada seção não ultrapasse muito além de 500 palavras.

Esta é a primeira edição de um livro sobre uma linguagem que vem apresentando interesse crescente. Naturalmente, o aumento de usuários - e espera-se que este livro contribua para isso - provocará também o surgimento de mais conhecimento, mais soluções criativas e que deverão ser incorporadas neste livro em futuras revisões. De fato, este texto já é a evolução do material que disponibizei por alguns anos como tutorial no gitBook.

Se o leitor encontrar algum erro ou quiser enviar alguma sugestão, por favor, encaminhe para o e-mail: livrosimulacao@gmail.com.

O plano proposto por este texto é caminhar pela seguinte sequência:

• Introdução ao SimPy
• Instalação do pacote
• Conceitos básicos: entidades, recursos, filas etc.
• Conceitos avançados: prioridade de recursos, compartilhamento de recursos, controle de filas, Store de recursos etc.
• Experimentação (replicações, tempo de warm-up, intervalos de confiança etc.)
• Simulação de agentes e otimização
• Aplicações

De tempos em tempos, se não chover e não fizer muito Sol, o autor se compromete a atualizar para novas versões do SimPy e do Python.

Nossa jornada começa por um breve tutorial de instalação de alguns programas e bibliotecas úteis para o SimPy. Selecionamos, para começar o tutorial, os seguintes pacotes:

1. Python 3.4
2. Pip
3. SimPy 3.0.10
4. NumPy

Um breve preâmbulo das nossas escolhas: no momento da elaboração deste tutorial, o Python estava na versão 3.5.0, mas o Anaconda (explicado adiante) ainda fornecia a versão 3.4. Se você já possui uma instalação com o Python 3.5 ou adelante, pode instalar o SimPy sem problemas, pois ele é compatível com as versões mais recentes do Python.

Pip é um instalador de bibliotecas e facilita muito a vida do programador.

O SimPy 3.0.10 é a versão mais atual no momento em que este tutorial é escrito e traz grandes modificações em relação à versão 2.0.

Quanto ao NumPy, vamos aproveitar o embalo para instalá-lo, pois será muito útil nos nossos modelos de simulação. Basicamente, NumPy acrescenta um tipo de dados (n-dimensional array) que facilita a codificação de modelos de simulação, particularmente na análise de dados de saída do modelo.

Se esta é a sua primeira vez, sugestão: não perca tempo e instale a distribuição gratuita do Anaconda.

Por meio do Anaconda, tudo é mais fácil, limpo e o processo já instala mais de 200 pacotes verificados por toda sorte de compatibilidade, para que você não tenha trabalho algum. (Entre os pacotes instalados está o NumPy que, como explicado, será muito útil no desenvolvimento dos seus modelos).

No momento de elaboração deste livro, eles disponibilizavam as versões 2.7, 3.4 e 3.5 do Python (em 32 e 64 bit) na página de downloads.

Baixe o arquivo com a versão desejada (mais uma vez: SimPy roda nas duas versões) e siga as instruções do instalador.

1. Baixe o pacote get-pip.py por meio deste link, salvando-o em uma pasta de trabalho conveniente.
2. Execute python get-pip.py na pasta de trabalho escolhida (note a mensagem ao final, confirmando que o pip foi instalado com sucesso).

Instalar o SimPy é fácil!

Digite em uma janela cmd:

A mensagem “Sucessfully installed simpy-3.0.10” indica que você já está pronto para o SimPy. Mas, antes disso, tenho uma sugestão para você:

Os IDEs, para quem não conhece, são verdadeiras interfaces de edição de código que facilitam a vida do programador. Geralmente possuem um editor de textos avançado, recursos de verificação de erros, monitores para os estados das variáveis do código, comandos de processamento passo-a-passo etc.

Se você instalou o Anaconda, então já ganhou um dos bons: o Spyder, que já está configurado e pronto para o uso. Geralmente (a depender da sua versão do Sistema Operacional) ele aparece como um ícone na área de trabalho. Se não localizar o ícone, procure por Spyder no seu computador (repare na pegadinha do “y”) ou digite em uma janela de cmd o comando spyder.

Aberto, o Spyder fica como a figura a seguir:

Outro IDE muito bom é o Wing IDE 101 que é gratuito (e também possui uma versão profissional paga):

Se você chegou até aqui e tem tudo instalado, o próximo passo é começar para valer com o SimPy!

Na próxima seção, é claro. Precisamos de uma pausa para um chazinho depois de tantos bytes instalados.

Antes de começarmos com o SimPy, precisamos garantir que você tenha algum conhecimento mínimo de Python. Se você julga que seus conhecimentos na linguagem são razoáveis, a recomendação é que você pule para a seção seguinte, “Teste seus conhecimentos em Python”.

Se você nunca teve contato com a linguagem, aviso que não pretendo construir uma “introdução” ou “tutorial” para o Python, simplesmente porque isso é o que mais existe à disposição na internet.

Procure um tutorial rápido (existem tutoriais de até 10 minutos!) e mãos à obra! Nada mais fácil do que aprender o básico de Python.

Sugestões:

1. Sololearn: um dos modos mais rápidos e bacanas de se aprender Python (e outras linguagens). São diversos cursos, divididos por níveis e que podem ser seguidos até pelo celular (sim, aprendi Java viajando pela linha azul do metrô de SP).
2. Introdução à Programação Interativa em Python (Parte 1): o Coursera tem um curso que vai ensiná-lo a criar programas que interagem com o usuário, isto é: joguinhos 😂. Eu fiz, é bom!
3. Summerfield, Mak. Programming in Python 3: a complete introduction. Addison-Wesley Professional. 2012: eu tenho sempre na minha mesa este ótimo livro de Python. Ele já foi traduzido para o Português e pode ser encontrado na amazon.

Feito o tutorial, curso ou aprendido mesmo tudo sozinho, teste seus conhecimentos para verificar se você sabe o básico necessário de Python para começar com o SimPy.

O problema da ruína do apostador é um problema clássico proposto por Pascal em uma carta para Fermat em 1656. A versão aqui apresentada é uma simplificação, visando avaliar seus conhecimentos em Python.

Agora é com você: complete o código anterior e descubra se você está pronto para inciar com o SimPy!
(A próxima seção apresenta uma possível resposta para o desafio e, na sequência, tudo enfim, começa.)

O código a seguir é uma possível solução para o desafio 1 da seção anterior. Naturalmente é possível deixá-lo mais claro, eficiente, obscuro, maligno, elegante, rápido ou lento, como todo código de programação. O importante é que se você fez alguma que coisa que funcione, acredito que é o suficiente para começar com o SimPy.

No meu computador, o problema anterior fornece o seguinte resultado:

Note que o resultado fornecido deve ser diferente em seu computador, assim como ele se modifica a cada nova rodada no programa. Para que os resultados entre o meu computador e o seu sejam semelhantes, precisamos garantir que a sequência de números aleatórios nos dois computadores sejam as mesmas. Isso é possível com o comando random.seed(semente), que estabelece um valor inicial fixo para a semente da sequência de números aleatórios gerada (veja o item 1 na seção “Teste seus conhecimentos”, na seção a seguir“).

Cada vez que você executa o programa, a função random.uniform(0,1) sorteia um novo número aleatório ente 0 e 1, tornando imprevisível o resultado do programa. Utilize a função random.seed(semente) para fazer com que a sequência gerada de números aleatórios seja sempre a mesma.

Acrescente um laço no programa principal de modo que o jogo possa ser repetido até um número pré definido de vezes. Simule 100 partidas e verifique em quantas cada um dos jogadores venceu.

Algo elementar em qualquer pacote de simulação é uma função para criar entidades dentro do modelo. É o “Alô mundo!” dos pacotes de simulação. Sua primeira missão, caso decida aceitá-la, será construir uma função que gere entidades com intervalos entre chegadas sucessivas exponencialmente distribuídos, com média de 2 min. Simule o sistema por 10 minutos apenas.

Inicialmente, serão necessárias duas bibliotecas do Python: a random – biblioteca de geração de números aleatórios – e a simpy, que é o próprio SimPy.

Nosso primeiro modelo de simulação em SimPy começa com as chamadas das respectivas bibliotecas de interesse:

Note a linha final random.seed(1000). Ela garante que a geração de números aleatórios sempre começará pela mesma semente, de modo que a sequência de números aleatórios gerados a cada execução programa será sempre a mesma, facilitando o processo de verificação do programa.

Tudo no SimPy gira em torno de eventos gerados por funções e todos os eventos devem ocorrer em um environment, ou um “ambiente” de simulação criado a partir da função simpy.Environment().

Assim, nosso programa deve conter ao menos uma chamada à função simpy.Environment(), criando um environment “env”:

Se você executar o programa anterior, nada acontece. No momento, você apenas criou um environment, mas não criou nenhum processo, portanto, não existe ainda nenhum evento a ser simulado pelo SimPy.

Vamos escrever uma função geraChegadas() que cria entidades no sistema enquanto durar a simulação. Nosso primeiro gerador de entidades terá três parâmetros de entrada: o environment, um atributo que representará o nome da entidade e a taxa desejada de chegadas de entidades por unidade de tempo. Para o SimPy, equivale dizer que você vai construir uma função geradora de eventos dentro do environment criado. No caso, os eventos gerados serão as chegadas de entidades no sistema.

Assim, nosso código começa a ganhar corpo:

Precisamos informar ao SimPy que a função geraChegadas() é, de fato, um processo que deve ser executado ao longo de toda a simulação. Um processo é criado dentro do environment, pelo comando:

A chamada ao processo é sempre feita após a criação do env, então basta acrescentar uma nova linha ao nosso código:

Inicialmente, precisamos gerar intervalos de tempos aleatórios, exponencialmente distribuídos, para representar os tempos entre chegadas sucessivas das entidades. Para gerar chegadas com intervalos exponenciais, utilizaremos a biblioteca random, bem detalhada na sua documentação, e que possui a função:

Onde lambd é a taxa de ocorrência dos eventos ou, matematicamente, o inverso do tempo médio entre eventos sucessivos. No caso, se queremos que as chegadas ocorram entre intervalos médios de 2 min, a função ficaria:

A linha anterior é basicamente nosso gerador de números aleatórios exponencialmente distribuídos. O passo seguinte será informar ao SimPy que queremos nossas entidades surgindo no sistema segundo a distribuição definida. Isso é feito pela chamada da palavra reservada yield com a função do SimPy env.timeout(intervalo), que nada mais é do que uma função que causa um atraso de tempo, um delay no tempo dentro do enviroment env criado:

Na linha de código anterior estamos executando yield env.timeout(0.5) para que o modelo retarde o processo num tempo aleatório gerado pela função random.expovariate(0.5).

Oportunamente, discutiremos mais a fundo qual o papel do palavra yield (spoiler: ela não é do SimPy, mas originalmente do próprio Python). Por hora, considere que ela é apenas uma maneira de criar eventos dentro do env e que, caso uma função represente um processo, obrigatoriamente ela precisará conter o comando yield *alguma coisa*, bem como o respectivo environment do processo.

Colocando tudo junto na função geraChegadas(), temos:

O código deve ser autoexplicativo: o laço while é infinito enquanto dure a simulação; um contador, contaChegada, armazena o total de entidades geradas e a função print, imprime na tela o instante de chegada de cada cliente. Note que, dentro do print, existe uma chamada para a hora atual de simulação env.now.
Por fim, uma chamada a função random.seed() garante que os números aleatórios a cada execução do programa serão os mesmos.

Se você executar o código anterior, nada acontece novamente, pois ainda falta informarmos ao SimPy qual o tempo de duração da simulação. Isto é feito pelo comando:

No exemplo proposto, o tempo de simulação deve ser de 10 min, como representado na linha 15 do código a seguir:

Ao executar o programa, temos a saída:

Agora sim!

Note que env.process(geraChegadas(env)) é um comando que torna a função geraChegadas() um processo ou um gerador de eventos dentro do Environment env. Esse processo só começa a ser executado na linha seguinte, quando env.run(until=10) informa ao SimPy que todo processo pertencente ao env deve ser executado por um tempo de simulação igual a 10 minutos.

Desafio 2: é comum que os comandos de criação de entidades nos softwares proprietários tenham a opção de limitar o número máximo de entidades geradas durante a simulação.
Modifique a função geraChegadas de modo que ela receba como parâmetro o numeroMaxChegadas e limite a criação de entidades a este número.

Neste caso, o script em Python é autoexplicativo, apenas note que limitei o número de chegadas em 5 e fiz isso antes da chamada do processo gerado pela função geraChegadas():

Desafio 3: modifique a função geraChegadasde modo que as chegadas entre entidades sejam distribuídas segundo uma distribuição triangular de moda 1, menor valor 0,1 e maior valor 1,1.

Neste caso, precisamos verificar na documentação da biblioteca random, quais são nossas opções. A tabela a seguir, resume as distribuições disponíveis:

A biblioteca NumPy, que veremos oportunamente, possui mais opções para distribuições estatísticas. Por enquanto, o desafio 3 pode ser solucionado de maneira literal:

Por exemplo, imagine um modelo em SimPy que possui 3 processos: um exponencial com média 10 min, um triangular com parâmetros (10, 20, 30) min e um normal com média 0 e desvio 1 minuto. A função distribution() a seguir, armazena todos os geradores de números aleatórios em um único local:

O próximo exemplo testa como chamar a função:

O qual produz a saída:

Essa foi a nossa dica do dia!

Fique a vontade para implementar funções de geração de números aleatórios ao seu gosto. Note, e isso é importante, que praticamente todos os seus modelos de simulação em SimPy precisarão deste tipo de função!

1. Acrescente ao programa inicial, uma função distribution como a proposta na Dica do Dia e faça o tempo entre chegadas sucessivas de entidades chamar a função para obter o valor correto.
2. Considere que 50% das entidades geradas durante a simulação são do sexo feminino e 50% do sexo masculino. Modifique o programa para que ele sorteie o gênero dos clientes. Faça esse sorteio dentro da função distribution já criada.

Em simulação, é usual representarmos processos que consomem recursos com alguma limitação de capacidade, tais como: máquinas de usinagem, operários em uma fábrica, empilhadeiras em um depósito etc. Quando um recurso é requisitado e não está disponível, há formação de uma fila de espera de entidades pela liberação do recurso.

Por exemplo, considere a simulação de uma fábrica, onde são necessários recursos “máquinas” que serão utilizados nos processos de fabricação.

No SimPy, a sintaxe para criar um recurso é:

Se o parâmetro capacity não for fornecido, a função assume capacity=1. Note que
maquinas foi criando dentro do Environment env.

Como comentado ao início da seção, muitos processos em simulação ocupam recursos. Assim, ocupar um recurso em um processo exige a codificação de uma função específica em que um dos argumentos deve ser o próprio recurso a ser utilizado. O trecho de código a seguir, exemplifica para o caso das máquinas já criadas:

É interessante notar que ocupar um recurso no SimPy é feito em duas etapas:

1. Requisitar o recurso desejado com um req = recurso.request() (o que é equivalente a entrar na fila para de acesso ao recurso);
2. Ocupar o recurso com um yield req.

Assim, uma chamada ao recurso maquinas ficaria:

Enquanto a entidade estiver em fila aguardando a liberação do recurso, ela permanece na linha do comando yield req. Quando ela finalmente ocupa o recurso, a execução passa para a linha seguinte (comando print, no caso do exemplo).

Se pode parecer estranho que a ocupação de um recurso envolva duas linhas de código, o bom observador deve notar que isso pode dar flexibilidade em situação de lógica intrincada.

Recurso criado e ocupado é liberado com a função release(req). Considerando, por exemplo, que o processamento de peça leva 5 minutos em uma máquina, nossa função processo ficaria:

Para testarmos nossa função, vamos executar o processo para apenas 4 peças e analisar o resultado. O código a seguir possui um laço for que chama a função processo 4 vezes no mesmo instante:

Quando executado, o programa retorna:

A saída da simulação permite concluir que as quatro peças chegaram no instante 0, mas como a capacidade do recurso era para apenas 2 peças simultâneas, as peças 3 e 4 tiveram que aguardar em fila até a liberação das máquinas no instante 5.

O SimPy fornece alguns parâmetros para você acompanhar o status do recursos criados no modelo. Para um recurso res definido no programa, podem ser extraídos os seguintes parâmetros durante a simulação:

• res.capacity: capacidade do recurso;
• res.count: quantas unidades de capacidade do recurso estão ocupadas no momento;
• res.queue: lista de objetos (no caso, requisições) que estão em fila no momento. Como res.queue é uma lista, o número de entidades em fila do recurso é obtido diretamente com o comando len(res.queue);
• res.users: lista de objetos (no caso, requisições) que estão ocupando o recurso no momento. Como res.users é uma lista, o número de entidades em processo no recurso é obtido diretamente com o comando len(res.users).

Ao exemplo anterior acrescentamos uma pequena função, printStatus, que imprime na tela todos os parâmetros anteriores de um recurso:

Quando executado, o programa anterior fornece como saída:

Esta seção para por aqui. Na continuação, construiremos um exemplo completo com geração de entidades e ocupação de recursos, de modo a cruzar tudo o que vimos até agora sobre o SimPy.

A fila M/M/1 (ver, por exemplo, Chwif e Medina, 2015 ) representa um sistema simples em que clientes chegam para atendimento em um servidor de fila única, com intervalos entre chegadas sucessivas exponencialmente distribuídos e tempos de atendimentos também exponencialmente distribuídos.

Para este exemplo, vamos considerar que o tempo médio entre chegadas sucessivas é de 1 min (ou seja, uma taxa de chegadas de 1 cliente/min) e o tempo médio de atendimento no servidor é de 0,5 min (ou seja, uma taxa de atendimento de 2 clientes/min). Como um experimento inicial, o modelo deve ser simulado por 5 minutos apenas.

Partindo da função geraChegadas, codificada na seção “Primeiro passo em SimPy: criando entidades”, precisamos criar uma função ou processo para ocupar, utilizar e desocupar o servidor. Criaremos uma função atendimentoServidor responsável por manter os clientes em fila e realizar o atendimento.

Inicialmente, vamos acrescentar as constantes TEMPO_MEDIO_CHEGADAS e TEMPO_MEDIO_ATENDIMENTO, para armazenar os parâmetros das distribuições dos processos de chegada e atendimento da fila. Adicionalmente, vamos criar o recurso servidorRes com capacidade de atender 1 cliente por vez.

Se você executar o script anterior, o recurso é criado, mas nada acontece, afinal, não existe ainda nenhum processo requisitando o recurso.

Precisamos, portanto, construir uma nova função que realize o processo de atendimento. Usualmente, um processo qualquer tem ao menos as 4 etapas a seguir:

1. Solicitar o servidor;
2. Ocupar o servidor;
3. Executar o atendimento por um tempo com distribuição conhecida;
4. Liberar o servidor para o próximo cliente.

A função atendimentoServidor, a seguir, recebe como parâmetros o env atual, o nome do cliente e a recurso servidorRes para executar todo o processo de atendimento.

Neste momento, nosso script possui uma função geradora de clientes e uma função de atendimento dos clientes, mas o bom observador deve notar que não existe conexão entre elas. Em SimPy, e vamos repetir isso a exaustão, tudo é processado dentro de um environment. Assim, o atendimento é um processo que deve ser iniciado por cada cliente gerado pela função criaChegadas. Isto é feito por uma chamada a funçãoenv.process(atendimentoServidor(...)).

A função geraChegadasdeve ser alterada, portanto, para receber como parâmetro o recurso servidorRes, criado no corpo do programa e para iniciar o processo de atendimento por meio da chamada à função env.process, como representado a seguir:

Agora execute o script e voilá!

A sequência de ocupação e desocupação do recurso pode ser representada de maneira mais compacta com o laço with:

No script anterior a ocupação e desocupação é garantida dentro do with, deixando o código mais compacto e legível. Contudo, a aplicação é limitada a problemas de ocupação e desocupação simples de servidores (veja um contra-exemplo no Desafio 6).

Existem muitos conceitos a serem discutidos sobre os scripts anteriores e, garanto, que eles serão destrinchados nas seções seguintes.

Por hora, e para não esticar demais a atividade, analise atentamente os resultados da execução do script e avance para cima dos nossos desafios.

Desafio 4: imprima na tela o tempo de simulação e o números de clientes em fila. Quantos clientes existem em fila no instante 4.5?

Para solução do desafio, basta lembrarmos que a qualquer momento, o conjunto de entidades em fila pelo recurso é dado por servidorRes.queue e, portanto, o número de entidade em fila é facilmente obtido pela expressão:

Foi acrescentada uma chamadas à função print, de modo a imprimir na tela o número de clientes em fila ao término do atendimento de cada cliente:

Executado o código, descobrimos que no instante 5,5 min, temos 2 clientes em fila:

Portanto, existem 0 cliente em fila no instante 4,5 minutos, nas condições simuladas (note a semente de geração de números aleatórios igual a 2).

Desafio 5: calcule o tempo de permanência em fila de cada cliente e imprima o resultado na tela. Para isso, armazene o instante de chegada do cliente na fila em uma variável chegada.
Ao final do atendimento, armazene o tempo de fila, numa variável tempoFila e apresente o resultado na tela.

A ideia deste desafio é que você se acostume com esse cálculo tão trivial quanto importante dentro da simulação: o tempo de permanência de uma entidade em algum local. Neste caso, o local é uma fila por ocupação de um recurso.
A lógica aqui é a de um cronometrista que deve disparar o cronômetro na chegada do cliente e pará-lo ao início do atendimento.
Assim, ao chegar, criamos uma variável chegada que armazena o instante atual fornecido pelo comando env.now do SimPy:

Agora, inciado o atendimento (logo após o yield que ocupa o recurso), a variável tempoFila armazena o tempo de permanência em fila. Como num cronômetro, o tempo em fila é calculado pelo instante atual do cronômetro menos o instante de disparo dele já armazenado na variável chegada:

Para imprimir o resultado, basta simplesmente alterar a chamada à função print na linha seguinte, de modo que o código final da função atendimentoServidor
fica:

Agora, a execução do programa mostra na tela o tempo de espera de cada cliente:

Desafio 6: um problema clássico de simulação envolve ocupar e desocupar recursos na seqüência correta. Considere uma lavanderia com 4 lavadoras, 3 secadoras e 5 cestos de roupas. Quando um cliente chega, ele coloca as roupas em uma máquina de lavar (ou aguarda em fila). A lavagem consome 20 minutos (constante). Ao terminar a lavagem, o cliente retira as roupas da máquina e coloca em um cesto e leva o cesto com suas roupas até a secadora, num processo que leva de 1 a 4 minutos distribuídos uniformemente. O cliente então descarrega as roupas do cesto diretamente para a secadora, espera a secagem e vai embora. Esse processo leva entre 9 e 12 minutos, uniformemente distribuídos. Construa um modelo que represente o sistema descrito.

A dificuldade do desafio da lavanderia é representar corretamente a sequência de ocupação e desocupação dos recursos necessários de cada cliente. Se você ocupá-los/desocupá-los na ordem errada, fatalmente seu programa apresentará resultados inesperados.

Como se trata de um modelo com vários processos e distribuições, vamos seguir a Dica da seção “Solução dos desafios 2 e 3” e construir uma função para armazenar as distribuições do problema, organizando nosso código:

Como já destacado, a dificuldade é representar a sequência correta de processos do cliente: ele chega, ocupa uma lavadora, lava, ocupa um cesto, libera uma lavadora, ocupa uma secadora, libera o cesto, seca e libera a secadora. Se a sequência foi bem compreendida, a máscara a seguir será de fácil preenchimento:

O programa a seguir apresenta uma possível solução para o desafio, já com diversos comandos de impressão:

A execução do programa anterior fornece como saída:

1. A fila M/M/1 possui expressões analíticas conhecidas. Por exemplo, o tempo médio de permanência no sistema é dado pela expressão: . Valide seu modelo, ou seja, calcule o resultado esperado para a expressão e compare com o resultado obtido pelo seu programa.

2. Utilizando a função plotda bilbioteca matplotlib, construa um gráfico que represente a evolução do número de entidades em fila (dica: você precisará armazenar o tempo de espera em uma lista e plotar a lista em um gráfico ao final da simulação).

3. No problema da lavanderia, crie uma situação de desistência, isto é: caso a fila de espera por lavadoras seja de 5 clientes, o próximo cliente a chegar no sistema desiste imediatamente de entrar na lavanderia.

Qual a diferença entre atributo e variável para um modelo de simulação? O atributo pertence à entidade, enquanto a variável pertence ao modelo. De outro modo, se um cliente chega a uma loja e compra 1, 2 ou 3 produtos, esse cliente possui um atributo imediato: o número de produtos comprados. Note que o atributo “número de produtos” é um valor diferente para cada cliente, ou seja: é um valor exclusivo do cliente.

Por outo lado, um parâmetro de saída importante seria o número total de produtos vendidos nesta loja ao longo da duração da simulação. O total de produtos é a soma dos atributos “número de produtos” de cada cliente que comprou algo na loja. Assim, o total vendido é uma variável do modelo, que se acumula a cada nova compra, independentemente de quem é o cliente.

Em SimPy a coisa é trivial: toda variável local funciona como atributo da entidade gerada e toda variável global é naturalmente uma variável do modelo. Não se trata de uma regra absoluta, nem tampouco foi imaginada pelos desenvolvedores da biblioteca, é decorrente da necessidade de se representar os processos do modelo de simulação por meio de funções que, por sua vez representam entidades executando alguma coisa.

Usuários de pacotes comerciais (Simul8, Anylogic, GPSS, Arena etc.) estão acostumados a informar explicitamente ao modelo o que é atributo e o que é variável. Em SimPy, basta lembrar que as variáveis globais serão variáveis de todo o modelo e que os atributos de interesse devem ser transferidos de um processo ao outro por transferência de argumentos no cabeçalho das funções.

Voltemos ao exemplo de chegadas de clientes numa loja. Queremos que cada cliente tenha como atributo o número de produtos desejados:

A execução do programa por apenas 5 minutos, apresenta como resposta:

É importante destacar no exemplo, que o cliente (ou entidade) gerado(a) pela função geraChegadasé enviado(a) para a função compra com seu atributo produtos, como se nota na linha em que o cliente chama o processo de compra:

Agora raciocine de modo inverso: seria possível representar o número total de produtos vendidos como uma variável local? Intuitivamente, somos levados a refletir na possibilidade de transferir o número total de produtos como uma parâmetro de chamada da função. Mas, reflita mais um tiquinho… É possível passar o total vendido como um parâmetro de chamada da função?

Do modo como o problema foi modelado, isso não é possível, pois cada chegada gera um novo processo compra independente para cada cliente e não há como transferir tal valor de uma chamada do processo para outra. A seção a seguir, apresenta uma alternativa interessante que evita o uso de variáveis globais num modelo de simulação.

Para aqueles que seguem o paradigma da programação orientada ao objeto, um atributo de uma entidade é naturalmente o próprio atributo do objeto gerado pela classe. Uma facilidade que a programação voltada ao objeto possui é que podemos criar atributos para recursos também. Neste caso, basta que o recurso seja criado dentro de uma classe.

Por exemplo, a fila M/M/1 poderia ser modelada por uma classe Servidor, em que um dos seus atributos é o próprio Resource do SimPy, como mostra o código a seguir:

Quando processado por apenas 5 minutos, o modelo anterior fornece:

No caso da programação voltada ao objeto, uma variável do modelo pode pertencer a uma classe, sem a necessidade de que a variável seja global. Por exemplo, o atributo clientesAtendidosda classe Servidor é uma variável que representa o total de cliente atendidos ao longo da simulação. Caso a representação utilizada não fosse voltada ao objeto, o número de clientes atendidos seria forçosamente uma variável global.

Desafio 7: retome o problema da lavanderia (Desafio 6). Estime o tempo médio que os clientes atendidos aguardaram pela lavadora.

O tempo médio de espera por fila de um recurso - no caso lavadoras - é estimado pelo soma do tempo que todos os clientes aguardaram pelo recurso, dividido pelo número de clientes que ocuparam o recurso ao longo da simulação.

Assim, vamos criar duas variáveis globais para armazenar a soma do tempo de espera por lavadora de todos os clientes que ocuparam as lavadoras, bem como o número de clientes que ocuparam as mesmas lavadoras:

A seguir, precisamos alterar a função lavaSeca para calcular corretamente o tempo de espera por lavadora de cada cliente, somar este valor à variável global tempoEsperaLavadora e incrementar o número de clientes que ocuparam lavadoras na variável global contaLavadora (representação apenas da parte do código que é alterada):

Ao final do programa, basta acrescentar uma linha para imprimir o tempo médio em fila de espera por lavadoras e o número de vezes que uma lavadora foi ocupada ao longo da simulação:

Quando executado por 40 minutos, o modelo completo com as alterações anteriores fornece como saída:

Desafio 8: no desafio anterior, caso você simule por 10 ou mais horas, deve notar como o tempo de espera pela lavadora fica muito alto. Para identificar o gargalo do sistema, acrescente a impressão do número de clientes que ficaram em fila ao final da simulação. Você consegue otimizar o sistema a partir do modelo construído?

Quando simulamos o sistema por 10 horas (=10*60 minutos), obtemos como resposta:

Para a solução do desafio, basta acrescentar uma linha ao final do programa principal que imprime as filas de por recursos (lavadoras, cestos e secadoras) ao final da simulação:

Quando simulado por 600 minutos (ou 10 horas), a saída do modelo fornece:

Portanto, ao final da simulação, existem 56 clientes aguardando uma lavadora livre, enquanto nenhum cliente aguarda por cestos ou secadoras. Temos um caso clássico de fila infinita, isto é: a taxa de horária de atendimento das lavadoras é menor que a taxa horária com que os clientes chegam à lavanderia. Assim, se 1 cliente ocupa em média 20 minutos uma lavadora, a taxa de atendimento em cada lavadora é de , enquanto a taxa de chegadas de clientes na lavandeira é de .

Como a taxa de atendimento é menor que a taxa de chegadas, a fila cresce indefinidamente. Para termos um sistema equilibrado, precisaríamos de um número de lavadoras tal que se garanta que a taxa de atendimento da soma das lavadoras seja maior que a taxa de chegadas de clientes no sistema ou:

Portanto, com 5 (ou mais) lavadoras eliminaríamos o gargalo na lavagem.

O bom da simulação é que podemos testar se a calculera anterior faz sentido. Quando simulado para 5 lavadoras, o modelo fornece como saída:

Com 5 lavadoras, portanto, já não existe fila residual.

1. Elabore uma pequena rotina capaz de simular o sistema para números diferentes de recursos (será que o número de cestos e secadoras não está exagerado também?). Manipule o modelo para encontrar o número mínimo de recursos necessário, de modo a não haver gargalos no sistema.

No SimPy, o Environment é quem coordena a execução do seu programa. Ele avança o relógio de simulação, planeja a ordem de execução dos eventos e executa cada evento planejado pelo programa no instante correto.

A maneira mais usual de controle de execução de um modelo de simulação é fornecendo a duração do experimento de simulação. O SimPy, como veremos, vai além e permite alguns outros modos de controle.

Incialmente, vamos trabalhar com um modelo simples, que gera chegadas de eventos em intervalos constantes entre si:

Quando executado, o modelo anterior fornece:

No modelo anterior, a última linha informa ao SimPy que a simulação deve ser executada até o instante 5 (implicitamente o SimPy assume que o instante inicial é 0). Esta é a maneira mais usual: o instante final de simulação é um parâmetro de entrada.

O interessante, no modelo anterior, é que se quisermos continuar a execução do instante atual (5, no caso) até o instante 10, por exemplo, podemos simplesmente acrescentar mais uma linha env.run(until=10) informando que a execução continua de onde está (instante 5) e termina em 10. Isto pode ser útil em situações em que precisamos modificar algum parâmetro de entrada do modelo ao longo da própria simulação.

Vamos modificar o modelo anterior de modo que nos primeiros 5 minutos o intervalo entre geração de chegadas seja de 1 minuto e, depois, até o instante 10, o intervalo seja de 2 minutos. Para isso, criamos uma variável global intervalo que armazenará o intervalo entre chegadas, como mostra o código a seguir:

Depois de executado, o modelo anterior fornece:

A segunda chamada do run, env.run(until=10), executou do instante atual (no caso, 5) até o instante 10. Assim, a opção until não representa a duração da simulação, mas até que instante queremos executá-la. Isto implica também, que uma nova chamada para env.run não reinicializa o tempo de simulação, isto é, não retorna o relógio do simulador para o instante 0.

Para reinicializar a relógio de um modelo em execução, o que seria equivalente a reinicializar a simulação, uma alternativa possível é acrescentar uma nova linha de criação do environment (e, nas linhas seguintes, realizar as chamadas de processo e do env.run). Por exemplo:

Agora, o modelo reinicializa o relógio, como pode-se verificar pela sua saída:

Quando não se fornece o tempo de simulação (ou ele não é conhecido a priori), podemos interromper a simulação pela própria extição do processo. No programa anterior, por exemplo, podemos substituir o comando while True por um laço fore executar a simulação com um número fixo de entidades pré estabelecido:

Quando executado, o modelo anterior fornce como saída:

Um modelo de simulação pode possuir diversos processos ocorrendo ao mesmo tempo, de modo que o término da simulação só é garantido quando todos os processos programados terminarem.

O próximo modelo amplia o exemplo anterior, de modo que dois processos são executados ao mesmo tempo, um com 3 entidades e outro com 5 entidades. Note que os processos também podem se armazendos em uma lista:

Quando executado, o modelos anterior fornece como saída:

Neste último exemplo, a simulação terminou apenas quando o processo “p1”, de 5 entidades, foi exaurido.

Uma outra alternativa de controle de execução é pelo término do próprio processo de execução. Partindo do exemplo anterior, podemos parar a simulação quando o processo que gera 3 entidades termina. Isto é possível com a opção env.run(until=processo):

Quando executado, o programa anterior fornece:

No programa anterior, a linha env.run(until=chegadas[1]) determina que o programa seja executado até que o processo chegadas[1] esteja concluído. Note que na lista:

chegadas[1]é o processo env.process(geraChegadas(env, "p2", 3)) que deve terminar após 3 entidades criadas. Verifique na saída do programa que, neste caso, de fato o programa parou após 3 entidades do tipo “p2” geradas.

O SimPy permite a simulação passo a passo por meio de dois comandos:

• peek(): retorna o instante de execução do próximo evento programado. Caso não existam mais eventos programados, retorna infinito (float('inf'));
• step(): processa o próximo evento. Caso não existam mais eventos, ele retorna um exceção interna EmptySchedule.

Um uso interessante da simulação passo a passo é na representação de barras de progresso. O exemplo a seguir faz uso da biblioteca pyprind para gerar uma barra de progresso simples (talvez você tenha de instalar a biblioteca pyprind - veja no link como proceder):