Reusing/Resetting SimPy Models with Different Environments
henrikw
Hi everyone,
I'm working on a simulation of a production process using SimPy, and I'm currently trying to optimize certain parameters through multiple simulation runs. For each run, I use different parameter values, which requires me to reset the simulation environment (simpy.Environment) each time.
Right now, I'm rebuilding the entire model from scratch for every simulation using a function like build_model(env)where I pass in a fresh environment. However, since my model is quite complex, rebuilding it repeatedly becomes a performance bottleneck. I would like to reuse the model structure and just reset the environment, or at least avoid having to fully reconstruct all components each time.
Has anyone found a good way to "recycle" or reuse an existing model while resetting the environment? Is there a way to replace or rebind environment-dependent methods (like process generators) to a new environment without reinitializing everything?
Here’s a simplified version of what I’m doing:
import simpy
import random
class Machine:
def __init__(self, env, processing_time):
self.env = env
self.processing_time = processing_time
self.process = env.process(self.run())
def run(self):
while True:
yield self.env.timeout(self.processing_time)
print(f"Processed at {self.env.now}")
def build_model(env, processing_time):
return Machine(env, processing_time)
# Run simulations with different parameters
for processing_time in [5, 10, 15]:
env = simpy.Environment()
machine = build_model(env, processing_time) # Instead of rebuilding I'd like to recycle the once build model with a new environment to start a new simulation at env.now = 0
env.run(until=50)
This works, but in the real model, build_model() initializes many interconnected components, which makes frequent rebuilding expensive.
What I’d like to do instead:
Reuse the structure (e.g., machine instances)
Just reset the env or "rebind" the model components to a new environment
Avoid reinitializing the full model tree
Is there a way to decouple the environment more cleanly or restructure my model for this kind of reuse? Any design patterns or best practices for this kind of use case?
Thanks in advance for any tips or ideas!
Adrian Mc
Cornelius Sheahan
--
You received this message because you are subscribed to the Google Groups "python-simpy" group.
To unsubscribe from this group and stop receiving emails from it, send an email to python-simpy...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/python-simpy/19b8463d-c363-4c3c-abf7-d030dc7c4a05n%40googlegroups.com.
henrikw
rac...@clarke.gen.nz
henrikw
To make the model reusable and avoid rebuilding it from scratch in each iteration, every component is extended by a reset() method, which optionally accepts a new SimPy Environment as a parameter.
When the model is “reset”, all SimPy-related attributes of its components are reinitialized using the new environment:
import gc
import objgraph
class Machine:
def __init__(self, env, processing_time, capacity=1):
self.env = env
self.processing_time = processing_time
self.resource = simpy.Resource(env, capacity=self.capacity)
self.action = env.process(self.run())
self.is_processing = env.event()
def run(self):
while True:
yield self.env.timeout(self.processing_time)
print(f"Processed at {self.env.now}")
# Reset attributes unrelated to SimPy.
# ...
# Reinitialize the SimPy-related parts of the object.
if env:
# Replace the old environment reference.
self.env = env
# Recreate environment-dependent attributes.
self.resource = simpy.Resource(env, capacity=self.capacity)
self.action = env.process(self.run())
self.is_processing = env.event()
class Model:
def __init__(self, env, processing_time):
self.machine = Machine(env, processing_time)
def reset(self, env):
# Reset all components with the new environment.
self.machine.reset(env)
# Example usage:
def run_simulation(iterations=5):
model = None
for i in range(iterations):
env = simpy.Environment()
if model is None:
# Build model only once.
model = Model(env, processing_time=5)
else:
# Just reset environment references.
model.reset(env)
# Evaluate the model or ave its simulation results.
# Check the results of the reset.
#gc.collect()
print("Simpy envs in memory:", sum(1 for o in gc.get_objects() if isinstance(o, simpy.Environment)))
objgraph.show_growth()
env.run(until=20)
print(f"Iteration {i+1} done\n")
run_simulation()
While this example is simplified, it demonstrates the reset procedure I use in my implementation.
The model itself is built only once, and then reset for every subsequent iteration using a new SimPy environment.
To ensure that only one SimPy environment remains in memory, I manually call the garbage collector (gc.collect()).
If you skip this step, the first SimPy environment will still be referenced somewhere and stay in memory — meaning you’ll typically see two environments at all times. However, since this number doesn’t increase over iterations, it’s usually not a problem.
To further verify that memory usage stays stable, I print out the number of SimPy environments currently in memory, and also display the number of newly created objects using objgraph.show_growth() after each reset.
This approach prevents my model from accumulating memory over time while allowing me to efficiently reset the SimPy environment between iterations.
Hope this helps!
Feel free to reach out if you have any more questions.
jar...@gmail.com
I even went so far as to put the environment in a context manager to be deleted on exit. Still no luck with whatever mutually dependent objects held references to each other I guess.
James