Package SimPy : gestion de la planification des événements

Simulation d’événements discrets en Python

Dr Diogo Costa

Adjunct Professor, University of Saskatchewan, Canada & CEO of ImpactBLUE-Scientific

Gérer l’occurrence des événements

L’occurrence d’événements réels peut être affectée par plusieurs situations.
Les plus courantes impliquent :
- événements conditionnels
- interruption d’événements
- attente de processus

Ces situations peuvent être modélisées en SimPy (événements discrets).

Événements conditionnels

Certains événements dépendent d’un autre événement
Ils ne se déclenchent que si une condition est remplie

Exemple

Des clients arrivent dans un magasin de vêtements
```
def customer_arrivals(env, shop)
```
Cherchent un article précis
```
env.timeout(search_time)
```

L’achètent seulement s’il est disponible

if shop.available[item]:

Générateur : rassembler tout le code

def customer_arrivals(env, shop):


    while True:

        yield env.timeout(search_time)


        # Acheter l’article seulement s’il est disponible
        if shop.available[item]:
            env.process(shop_buyer(env, item, 
                    num_items, shop))

Interruption d’événements

Certains événements peuvent être interrompus en raison de :

Événements de priorité supérieure
Interruption volontaire (p. ex., recharge d’une voiture)
Interruption forcée (p. ex., panne machine)

Méthode

simpy_process_1.interrupt()

Exemple

Une machine tombe périodiquement en panne, interrompant la production.

def break_machine(env):

  # Panne périodique de la machine.
  while True:

    # Temps entre pannes
    yield env.timeout(fail_time())


    # Panne : interrompre le processus
    simpy_process_1.interrupt()

Attente de processus

Certains processus doivent attendre que d’autres se terminent
Cela arrive souvent car les ressources sont limitées
Exemple : ressource partagée avec capacity=5 :
```
simpy.Resource(env, capacity=5)
```
Ainsi, un processus peut attendre si toutes les ressources sont occupées

Exemple : Les réserves d’essence d’une station doivent être régulièrement réapprovisionnées

with gas_station.request() as request:

  # Demander une pompe
  yield request


  # Une fois la pompe disponible : distribuer le carburant 
  liters_request = 10
  yield fuel_reserve.get(liters_request)

  # Le « vrai » ravitaillement prend du temps
  refuel_duration = liters_request 
                      / refuel_speed


  yield env.timeout(refuel_duration)

Concaténer des événements avec des opérateurs binaires

Opérateurs binaires

Effectuent des calculs bit à bit sur des entiers
Attendent deux opérandes
- Exemple : a & b, a >> b, a ^ b

Dans SimPy

Génère un événement conditionnel
Entre 2 événements

Opérateurs binaires utiles pour SimPy

Attend les deux processus : __and__() ou &
Attend l’un des processus : __or__() ou |

Concaténer des événements avec des opérateurs binaires

Exemple : Un spectateur attend à la billetterie jusqu’à son tour ou l’épuisement des billets

with counter.request() as my_turn:


  # Attendre son tour ou l’épuisement des billets
  result = yield my_turn | counter.sold_out[movie]


  # Si des billets sont disponibles
  if my_turn in result:
    theater.num_moviegoers[movie] += 1
    return


  # Si les billets sont épuisés
  if my_turn not in result:
    theater.num_renegers[movie] += 1
    return

Passons à la pratique !

Simulation d’événements discrets en Python