SimPy Shared Resources

This guide covers all resource types in SimPy for modeling congestion points and resource allocation.

Resource Types Overview

SimPy provides three main categories of shared resources:

Resources - Limited capacity resources (e.g., gas pumps, servers)
Containers - Homogeneous bulk materials (e.g., fuel tanks, silos)
Stores - Python object storage (e.g., item queues, warehouses)

1. Resources

Model resources that can be used by a limited number of processes at a time.

Resource (Basic)

The basic resource is a semaphore with specified capacity.

python

import simpy

env = simpy.Environment()
resource = simpy.Resource(env, capacity=2)

def process(env, resource, name):
    with resource.request() as req:
        yield req
        print(f'{name} has the resource at {env.now}')
        yield env.timeout(5)
        print(f'{name} releases the resource at {env.now}')

env.process(process(env, resource, 'Process 1'))
env.process(process(env, resource, 'Process 2'))
env.process(process(env, resource, 'Process 3'))
env.run()

Key properties:

capacity - Maximum number of concurrent users (default: 1)
count - Current number of users
queue - List of queued requests

PriorityResource

Extends basic resource with priority levels (lower numbers = higher priority).

python

import simpy

env = simpy.Environment()
resource = simpy.PriorityResource(env, capacity=1)

def process(env, resource, name, priority):
    with resource.request(priority=priority) as req:
        yield req
        print(f'{name} (priority {priority}) has the resource at {env.now}')
        yield env.timeout(5)

env.process(process(env, resource, 'Low priority', priority=10))
env.process(process(env, resource, 'High priority', priority=1))
env.run()

Use cases:

Emergency services (ambulances before regular vehicles)
VIP customer queues
Job scheduling with priorities

PreemptiveResource

Allows high-priority requests to interrupt lower-priority users.

python

import simpy

env = simpy.Environment()
resource = simpy.PreemptiveResource(env, capacity=1)

def process(env, resource, name, priority):
    with resource.request(priority=priority) as req:
        try:
            yield req
            print(f'{name} acquired resource at {env.now}')
            yield env.timeout(10)
            print(f'{name} finished at {env.now}')
        except simpy.Interrupt:
            print(f'{name} was preempted at {env.now}')

env.process(process(env, resource, 'Low priority', priority=10))
env.process(process(env, resource, 'High priority', priority=1))
env.run()

Use cases:

Operating system CPU scheduling
Emergency room triage
Network packet prioritization

2. Containers

Model production and consumption of homogeneous bulk materials (continuous or discrete).

python

import simpy

env = simpy.Environment()
container = simpy.Container(env, capacity=100, init=50)

def producer(env, container):
    while True:
        yield env.timeout(5)
        yield container.put(20)
        print(f'Produced 20. Level: {container.level}')

def consumer(env, container):
    while True:
        yield env.timeout(7)
        yield container.get(15)
        print(f'Consumed 15. Level: {container.level}')

env.process(producer(env, container))
env.process(consumer(env, container))
env.run(until=50)

Key properties:

capacity - Maximum amount (default: float('inf'))
level - Current amount
init - Initial amount (default: 0)

Operations:

put(amount) - Add to container (blocks if full)
get(amount) - Remove from container (blocks if insufficient)

Use cases:

Gas station fuel tanks
Buffer storage in manufacturing
Water reservoirs
Battery charge levels

3. Stores

Model production and consumption of Python objects.

Store (Basic)

Generic FIFO object storage.

python

import simpy

env = simpy.Environment()
store = simpy.Store(env, capacity=2)

def producer(env, store):
    for i in range(5):
        yield env.timeout(2)
        item = f'Item {i}'
        yield store.put(item)
        print(f'Produced {item} at {env.now}')

def consumer(env, store):
    while True:
        yield env.timeout(3)
        item = yield store.get()
        print(f'Consumed {item} at {env.now}')

env.process(producer(env, store))
env.process(consumer(env, store))
env.run()

Key properties:

capacity - Maximum number of items (default: float('inf'))
items - List of stored items

Operations:

put(item) - Add item to store (blocks if full)
get() - Remove and return item (blocks if empty)

FilterStore

Allows retrieval of specific objects based on filter functions.

python

import simpy

env = simpy.Environment()
store = simpy.FilterStore(env, capacity=10)

def producer(env, store):
    for color in ['red', 'blue', 'green', 'red', 'blue']:
        yield env.timeout(1)
        yield store.put({'color': color, 'time': env.now})
        print(f'Produced {color} item at {env.now}')

def consumer(env, store, color):
    while True:
        yield env.timeout(2)
        item = yield store.get(lambda x: x['color'] == color)
        print(f'{color} consumer got item from {item["time"]} at {env.now}')

env.process(producer(env, store))
env.process(consumer(env, store, 'red'))
env.process(consumer(env, store, 'blue'))
env.run(until=15)

Use cases:

Warehouse item picking (specific SKUs)
Job queues with skill matching
Packet routing by destination

PriorityStore

Items retrieved in priority order (lowest first).

python

import simpy

class PriorityItem:
    def __init__(self, priority, data):
        self.priority = priority
        self.data = data

    def __lt__(self, other):
        return self.priority < other.priority

env = simpy.Environment()
store = simpy.PriorityStore(env, capacity=10)

def producer(env, store):
    items = [(10, 'Low'), (1, 'High'), (5, 'Medium')]
    for priority, name in items:
        yield env.timeout(1)
        yield store.put(PriorityItem(priority, name))
        print(f'Produced {name} priority item')

def consumer(env, store):
    while True:
        yield env.timeout(5)
        item = yield store.get()
        print(f'Retrieved {item.data} priority item')

env.process(producer(env, store))
env.process(consumer(env, store))
env.run()

Use cases:

Task scheduling
Print job queues
Message prioritization

Choosing the Right Resource Type

Scenario	Resource Type
Limited servers/machines	Resource
Priority-based queuing	PriorityResource
Preemptive scheduling	PreemptiveResource
Fuel, water, bulk materials	Container
Generic item queue (FIFO)	Store
Selective item retrieval	FilterStore
Priority-ordered items	PriorityStore

Best Practices

Capacity planning: Set realistic capacities based on system constraints
Request patterns: Use context managers (with resource.request()) for automatic cleanup
Error handling: Wrap preemptive resources in try-except for Interrupt handling
Monitoring: Track queue lengths and utilization (see monitoring.md)
Performance: FilterStore and PriorityStore have O(n) retrieval time; use wisely for large stores