SimPy

SimPy ("Simulation in Python") é um ambiente para a simulação de eventos discretos baseado no Python. Seu despachador de eventos é baseado em funções geradoras e também pode ser usado para redes assíncronas ou para implementar sistemas de multiagentes (tanto com comunicação simulada, quando real).

SimPy
Surgido em	2002
Última versão	3.0.9 (12 de junho de 2016)
Criado por	Klaus G. Müller, Tony Vignaux
Licença	MIT
Página oficial	simpy.readthedocs.org

Processos em SimPy são meras funções geradoras em Python e são utilizadas para modelar entidades, tais como: clientes, veículos ou agentes. SimPy também fornece vários tipos de recursos compartilhados para modelar sistemas com capacidade limitada (como servidores, guichês de atendimento, estações de trabalho etc.). A partir da versão 3.1, serão disponibilizados recursos de monitoramento, que permitirão extrair diversas estatísticas sobre recursos e processos existentes em um modelo.

As simulações podem ser realizadas "o mais rápido quanto possível", avançando o tempo de simulação ou manualmente, eventos a evento.

Embora seja teoricamente possível fazer simulações de processos contínuos com o SimPy, ele não nenhum recursos específico para realizar isso. No entanto, SimPy é excelente para as simulações com um tamanho fixo de passo, onde os processos não interagem um com os outros ou com recursos partilhados — um simples loop while é suficiente neste caso.

A distribuição do SimPy contém tutoriais, documentação detalhada e um grande número de exemplos.

SimPy é um software open source sob a Licença MIT. A sua primeira versão foi lançada em Dezembro de 2002.

Exemplo: relógio

Um dos objetivos principais do SimPy é sua facilidade de uso. A seguir apresenta-se um exemplo de simulação em SimPy: um relógio imprime na tela o tempo corrente de simulação a cada passo:

 >>> import simpy
 >>>
 >>> def clock(env, name, tick):
 ...     while True:
 ...         print(name, env.now)
 ...         yield env.timeout(tick)
 ...
 >>> env = simpy.Environment()
 >>> env.process(clock(env, 'fast', 0.5))
 <Process(clock) object at 0x...>
 >>> env.process(clock(env, 'slow', 1))
 <Process(clock) object at 0x...>
 >>> env.run(until=2)
 fast 0

Exemplo: fila M/M/1

Uma possível modelagem para um sistema de fila M/M/1 é dada no código a seguir:

"""
Fila M/M/1
"""
import random
import simpy

qtdClientes = 10
taxaChegada = 1.0 / 6.0        #Inverso do intervalo médio entre chegadas em minutos
taxaAtendimento = 1.0 / 5.0    #Inverso do tempo de médio de atendimento em minutos

def chegadas(env):
    """ Gera as chegadas dos clientes no sistema """
    for i in range(qtdClientes):
        yield env.timeout(random.expovariate(taxaChegada))
        name = 'Cliente %d' % (i+1)
        env.process(atendimento(env, name))

def atendimento(env, name):
    """ Simula atendimento dos clientes no servidor 1 """
    print('%7.2f\t Chegada\t %s' % (env.now, name))
    atendReq = Servidor1.request()
    yield atendReq
    print('%7.2f\t Atendimento\t %s' % (env.now, name))
    yield env.timeout(random.expovariate(taxaAtendimento))
    Servidor1.release(atendReq)
    print('%7.2f\t Partida\t %s' % (env.now, name))
 
""" Bloco principal """
print('\nM/M/1\n')
print('Tempo\t', 'Evento\t\t', 'Cliente\n')

random.seed(10)
env = simpy.Environment()
Servidor1 = simpy.Resource(env, capacity=1)
env.process(chegadas(env))
env.run()

Note-se, no exemplo anterior, a função geradora "chegada" que cria clientes no sistema com intervalos de tempo exponencialmente distribuídos entre si. A função ainda faz uma chamada à outra função geradora, "atendimento", responsável por atender o cliente e manter aqueles clientes que encontram o servidor ocupado em fila.

Ver também

• Lista de softwares de simulação
• Simulação de Eventos Discretos

Ligações externas

• Sítio oficial
• Site oficial da linguagem Python
• Tutorial do SimPy em português