Model Musings
SimPy PreemptiveResource Explained: Interrupting for Priority
- Published
- Reading time
- 4 min
PreemptiveResource is the aggressive sibling of PriorityResource. It doesn’t just jump the queue; it kicks out whoever’s currently using the resource.
PriorityResource vs PreemptiveResource
PriorityResource: “I’ll wait, but put me first in line.”
PreemptiveResource: “Move. Now.”
import simpy
# Priority: high priority waits for current user to finish
priority_resource = simpy.PriorityResource(env, capacity=1)
# Preemptive: high priority interrupts current user
preemptive_resource = simpy.PreemptiveResource(env, capacity=1)
Basic Example
import simpy
def task(env, name, resource, priority, duration, arrival=0):
yield env.timeout(arrival)
with resource.request(priority=priority) as req:
yield req
try:
print(f"{name} starts at {env.now}")
yield env.timeout(duration)
print(f"{name} finishes at {env.now}")
except simpy.Interrupt as interrupt:
print(f"{name} preempted at {env.now}")
env = simpy.Environment()
cpu = simpy.PreemptiveResource(env, capacity=1)
env.process(task(env, "LowPriority", cpu, priority=10, duration=10))
env.process(task(env, "HighPriority", cpu, priority=1, duration=3, arrival=2))
env.run()
Output:
LowPriority starts at 0
LowPriority preempted at 2
HighPriority starts at 2
HighPriority finishes at 5
The high-priority task arrives at 2 and immediately interrupts the low-priority one. Why the two-unit delay? Had both arrived at 0, LowPriority would have been evicted before it even resumed from yield req (outside its try block); the unhandled Interrupt would then have stopped the run. Preemption can strike at any yield while you hold (or have just been granted) the resource.
Handling Preemption
When preempted, simpy.Interrupt is raised. You must handle it:
def job(env, resource, priority):
with resource.request(priority=priority) as req:
yield req
try:
yield env.timeout(10)
except simpy.Interrupt:
# What happens when preempted?
print("I got kicked out!")
# Maybe try again, maybe give up
Without the try/except, preemption crashes your process.
Resuming After Preemption
Common pattern: resume where you left off:
def resilient_job(env, resource, priority, total_work):
remaining = total_work
while remaining > 0:
with resource.request(priority=priority) as req:
yield req
start = env.now
try:
yield env.timeout(remaining)
remaining = 0 # Completed
except simpy.Interrupt:
remaining -= (env.now - start) # Work done
print(f"Preempted, {remaining:.1f} remaining")
print(f"Completed at {env.now}")
The job keeps trying until all work is done, even if repeatedly preempted.
Real-World Examples
Machine Repair
def regular_job(env, machine, duration):
with machine.request(priority=2) as req:
yield req
try:
yield env.timeout(duration)
print(f"Job completed at {env.now}")
except simpy.Interrupt:
print(f"Job interrupted for repair at {env.now}")
def repair(env, machine):
with machine.request(priority=1) as req: # Higher priority
yield req
print(f"Repair starts at {env.now}")
yield env.timeout(5)
print(f"Repair ends at {env.now}")
def breakdown(env, machine):
yield env.timeout(3) # Break down at time 3
env.process(repair(env, machine))
env = simpy.Environment()
machine = simpy.PreemptiveResource(env, capacity=1)
env.process(regular_job(env, machine, 10))
env.process(breakdown(env, machine))
env.run()
Emergency Override
NORMAL = 10
EMERGENCY = 1
def use_resource(env, name, resource, priority):
with resource.request(priority=priority) as req:
yield req
try:
print(f"{name} using resource at {env.now}")
yield env.timeout(20)
print(f"{name} finished at {env.now}")
except simpy.Interrupt:
print(f"{name} yielded to emergency at {env.now}")
Preemption Order
Like PriorityResource, lower priority number = more important:
# Priority 1 preempts priority 5
# Priority 5 preempts priority 10
# Equal priorities: later arrival cannot preempt
Equal priorities don’t preempt each other; that would cause infinite loops.
Preventing Preemption
Some requests shouldn’t be preempted:
with resource.request(priority=5, preempt=False) as req:
yield req
# This won't be interrupted by higher priority
yield env.timeout(10)
preempt=False means “I respect priority order in the queue, but once I’m running, don’t interrupt me.”
Statistics with Preemption
Track preemptions:
import random
import simpy
stats = {'completed': 0, 'preempted': 0}
def job(env, resource, priority):
with resource.request(priority=priority) as req:
try:
yield req # Inside the try: preemption can strike as soon as it is granted
yield env.timeout(10)
stats['completed'] += 1
except simpy.Interrupt:
stats['preempted'] += 1
def arrivals(env, resource):
while True:
yield env.timeout(random.expovariate(1/15))
env.process(job(env, resource, priority=random.choice([1, 5, 10])))
random.seed(42)
env = simpy.Environment()
machine = simpy.PreemptiveResource(env, capacity=1)
env.process(arrivals(env, machine))
env.run(until=1000)
# After the simulation; no finished or preempted jobs means nothing to divide by
total = stats['completed'] + stats['preempted']
if total:
print(f"Preemption rate: {stats['preempted']/total*100:.1f}% of {total} jobs")
else:
print("No jobs finished or were preempted")
Output:
Preemption rate: 19.7% of 66 jobs
When to Use PreemptiveResource
Use when:
- Emergency handling (machine breakdown repair)
- Real-time systems with hard deadlines
- Operating system CPU scheduling
- Critical process must start immediately
Don’t use when:
- Work can’t be resumed (preemption wastes it)
- Fairness matters
- Starvation of low priority is unacceptable
- The real system doesn’t actually preempt
The Danger of Preemption
Preemption can cause:
- Wasted work (if preempted jobs restart from scratch)
- Starvation (low priority never finishes)
- Complexity (handling interrupts everywhere)
Use judiciously. Often PriorityResource is enough.
Comparison Table
| Feature | Resource | PriorityResource | PreemptiveResource |
|---|---|---|---|
| Queue order | FIFO | Priority | Priority |
| Interrupts | No | No | Yes |
| Requires interrupt handling | No | No | Yes |
| Fair | Yes | No | No |
Example: Operating System Scheduler
def process(env, name, cpu, priority, burst_time):
remaining = burst_time
while remaining > 0:
with cpu.request(priority=priority) as req:
yield req
start = env.now
try:
yield env.timeout(remaining)
remaining = 0
print(f"{name} finished at {env.now}")
except simpy.Interrupt:
remaining -= (env.now - start)
print(f"{name} preempted, {remaining:.1f} remaining")
env = simpy.Environment()
cpu = simpy.PreemptiveResource(env, capacity=1)
# Low priority background task
env.process(process(env, "Background", cpu, priority=10, burst_time=20))
# High priority arrives later
def spawn_high_priority(env, cpu):
yield env.timeout(5)
env.process(process(env, "HighPriority", cpu, priority=1, burst_time=5))
env.process(spawn_high_priority(env, cpu))
env.run()
Summary
PreemptiveResource:
- Interrupts lower-priority current users
- Requires try/except for interrupt handling
- Useful for emergencies and real-time systems
- Can cause starvation and wasted work
Preemption is powerful. Use it when the situation demands it.