def test_when_empty(env): def proc(env, queue): yield queue.when_empty() assert env.now == 0 yield queue.put('a') yield queue.put('b') with queue.when_empty() as when_empty_ev: assert not when_empty_ev.triggered yield env.timeout(1) item = yield queue.get() assert item == 'a' assert not when_empty_ev.triggered with queue.when_empty() as when_empty_ev: assert not when_empty_ev.triggered yield env.timeout(1) with queue.get() as get_ev: item = yield get_ev assert item == 'b' assert when_empty_ev.triggered yield when_empty_ev env.process(proc(env, Queue(env))) env.run()
def test_when_at_most(env): def proc(env, queue): for item in 'abc': with queue.put(item) as put_ev: yield put_ev at_most = {} at_most[0] = queue.when_at_most(0) at_most[3] = queue.when_at_most(3) at_most[1] = queue.when_at_most(1) at_most[2] = queue.when_at_most(2) assert not at_most[0].triggered assert not at_most[1].triggered assert not at_most[2].triggered assert at_most[3].triggered item = yield queue.get() assert item == 'a' assert not at_most[0].triggered assert not at_most[1].triggered assert at_most[2].triggered item = yield queue.get() assert item == 'b' assert not at_most[0].triggered assert at_most[1].triggered item = yield queue.get() assert item == 'c' assert at_most[0].triggered env.process(proc(env, Queue(env))) env.run()
def test_mq_when_full(env): queue = Queue(env, capacity=2) result = [] def producer(env): yield env.timeout(1) for i in range(5): yield queue.put(i) yield env.timeout(1) def consumer(env): yield env.timeout(5) for i in range(3): msg = yield queue.get() assert msg == i def full_waiter(env): yield queue.when_full() result.append('full') def any_waiter(env): yield queue.when_any() assert env.now == 1 result.append('any') env.process(producer(env)) env.process(consumer(env)) env.process(full_waiter(env)) env.process(any_waiter(env)) env.process(any_waiter(env)) env.run() assert queue.items assert queue.is_full assert 'full' in result assert result.count('any') == 2
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.pump_rate = self.env.config.get('tanker.pump_rate', 10) self.avg_travel = self.env.config.get('tanker.travel_time', 600) tank_capacity = self.env.config.get('tanker.capacity', 200) self.tank = Pool(self.env, tank_capacity) # This auto_probe() call uses the self.tank Pool get/put hooks so that # whenever it's level changes, the new level is noted in the log. self.auto_probe('tank', log={}) # The parent TankerCompany enqueues instructions to this queue. self._instructions = Queue(self.env) # Declare a persistant process to be started at simulation-time. self.add_process(self._dispatch_loop)
def test_when_at_least(env): def proc(env, queue): at_least = {} at_least[3] = queue.when_at_least(3) at_least[0] = queue.when_at_least(0) at_least[2] = queue.when_at_least(2) at_least[1] = queue.when_at_least(1) assert at_least[0].triggered assert not at_least[1].triggered assert not at_least[2].triggered assert not at_least[3].triggered yield queue.put('a') assert at_least[1].triggered assert not at_least[2].triggered assert not at_least[3].triggered yield queue.get() assert not at_least[2].triggered assert not at_least[3].triggered yield queue.put('b') assert not at_least[2].triggered assert not at_least[3].triggered yield queue.put('c') assert at_least[2].triggered assert not at_least[3].triggered yield queue.put('d') assert at_least[3].triggered env.process(proc(env, Queue(env))) env.run()
def __init__(self, *args, **kwargs): super(TopTest, self).__init__(*args, **kwargs) self.container = simpy.Container(self.env) self.resource = simpy.Resource(self.env) self.queue = Queue(self.env) self.pool = Pool(self.env) self.a = CompA(self) self.b = CompB(self) hints = {} if self.env.config['sim.log.enable']: hints['log'] = {'level': 'INFO'} if self.env.config['sim.vcd.enable']: hints['vcd'] = {} if self.env.config['sim.db.enable']: hints['db'] = {} self.auto_probe('container', **hints) self.auto_probe('resource', **hints) self.auto_probe('queue', **hints) self.auto_probe('pool', **hints) self.trace_some = self.get_trace_function('something', vcd={'var_type': 'real'}, log={'level': 'INFO'}) self.trace_other = self.get_trace_function('otherthing', vcd={ 'var_type': 'integer', 'init': ('z', 'z'), 'size': (8, 8) }) self.add_process(self.loop)
def __init__(self, *args, **kwargs): super(TankerTruck, self).__init__(*args, **kwargs) self.pump_rate = self.env.config.get('tanker.pump_rate', 10) self.avg_travel = self.env.config.get('tanker.travel_time', 600) tank_capacity = self.env.config.get('tanker.capacity', 200) self.tank = Container(self.env, tank_capacity) # This auto_probe() call causes the self.tank Container to be # monkey-patched such that whenever it's level changes, the new level # is noted in the log. self.auto_probe('tank', log={}) # The parent TankerCompany enqueues instructions to this queue. self._instructions = Queue(self.env) # Declare a persistent process to be started at simulation-time. self.add_process(self._dispatch_loop)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.cashier = Cashier(self) self.customer_queue = Resource(self.env) self.auto_probe('customer_queue', trace_queue=True, vcd={'init': 0}) feed_capacity = self.env.config['checkout.feed_capacity'] self.feed_belt = Queue(self.env, capacity=feed_capacity) self.auto_probe('feed_belt', vcd={}) bag_area_capacity = self.env.config['checkout.bag_area_capacity'] self.bag_area = Queue(self.env, capacity=bag_area_capacity) self.auto_probe('bag_area', vcd={}) self.baggers = Container(self.env) self.auto_probe('baggers', vcd={})
def test_queue_peek(env): queue = Queue(env) assert queue.is_empty with raises(IndexError): queue.peek() queue2 = Queue(env, items=[9, 8, 7]) assert not queue2.is_empty assert queue2.peek() == 9
def test_queue_cancel(env): queue = Queue(env, capacity=2) def producer(env): for i in range(5): yield env.timeout(5) yield queue.put(i) def consumer(env): for i in range(3): yield env.timeout(10) msg = yield queue.get() assert msg == i def canceller(env): any_ev = queue.when_any() get_ev = queue.get() full_ev = queue.when_full() yield env.timeout(1) assert not get_ev.triggered assert not any_ev.triggered assert not full_ev.triggered get_ev.cancel() any_ev.cancel() full_ev.cancel() assert not queue.is_full with queue.when_full() as when_full: yield when_full with queue.put(1) as put_ev: not_full_ev = queue.when_not_full() yield env.timeout(1) assert not put_ev.triggered assert not not_full_ev.triggered not_full_ev.cancel() yield env.timeout(100) assert not get_ev.triggered assert not any_ev.triggered assert not put_ev.triggered assert not put_ev.triggered assert not not_full_ev.triggered env.process(producer(env)) env.process(consumer(env)) env.process(canceller(env)) env.run()
def test_queue_overflow(env): def proc(env, queue): yield queue.put(1) yield env.timeout(1) yield queue.put(1) yield env.timeout(1) with raises(OverflowError): yield queue.put(1) queue = Queue(env, capacity=2, hard_cap=True) env.process(proc(env, queue)) env.run()
class CheckoutLane(Component): base_name = 'lane' def __init__(self, *args, **kwargs): super(CheckoutLane, self).__init__(*args, **kwargs) self.queue = Queue(self.env) self.auto_probe('queue', vcd={}) self.add_process(self.checkout) def __lt__(self, other): return self.queue.size < other.queue.size def enqueue(self, num_items, done_event): return self.queue.put((num_items, done_event)) def checkout(self): scan_dist = partial(self.env.rand.expovariate, 1 / self.env.config['grocery.scan_time']) while True: num_items, done_event = yield self.queue.get() for n in range(num_items): yield self.env.timeout(scan_dist()) done_event.succeed()
def test_attach_queue_size(env): values = [] queue = Queue(env) attach('scope', queue, [values.append]) def proc(): yield queue.put('item0') yield queue.put('item1') yield queue.put('item2') item = yield queue.get() assert item == 'item0' env.process(proc()) env.run() assert values == [1, 2, 3, 2]
def __init__(self, *args, **kwargs): super(TankerTruck, self).__init__(*args, **kwargs) self.pump_rate = self.env.config.get('tanker.pump_rate', 10) self.avg_travel = self.env.config.get('tanker.travel_time', 600) tank_capacity = self.env.config.get('tanker.capacity', 200) self.tank = Pool(self.env, tank_capacity) # This auto_probe() call uses the self.tank Pool get/put hooks so that # whenever it's level changes, the new level is noted in the log. self.auto_probe('tank', log={}) # The parent TankerCompany enqueues instructions to this queue. self._instructions = Queue(self.env) # Declare a persistant process to be started at simulation-time. self.add_process(self._dispatch_loop)
def test_attach_queue_remaining(env): values = [] queue = Queue(env, capacity=10) attach('scope', queue, [values.append], trace_remaining=True) def proc(): yield queue.put('item0') yield queue.put('item1') yield queue.put('item2') item = yield queue.get() assert item == 'item0' env.process(proc()) env.run() assert values == [9, 8, 7, 8]
def test_mq(env): queue = Queue(env, capacity=2) def producer(msg, wait): yield env.timeout(wait) yield queue.put(msg) def consumer(expected_msg, wait): yield env.timeout(wait) msg = yield queue.get() assert msg == expected_msg env.process(producer('1st', 0)) env.process(producer('2nd', 1)) env.process(consumer('1st', 0)) env.process(consumer('2nd', 1)) env.run()
def test_when_not_full(env): queue = Queue(env, capacity=2, items=[0, 1]) def consumer(env): for i in range(2): yield env.timeout(3) msg = yield queue.get() assert msg == i def not_full_waiter(env): yield queue.when_not_full() assert env.now == 3 yield queue.when_not_full() assert env.now == 3 env.process(consumer(env)) env.process(not_full_waiter(env)) env.run()
class TankerTruck(Component): """Tanker trucks carry fuel to gas stations. Each tanker truck has a queue of gas stations it must visit. When the truck's tank becomes empty, it must go refill itself. """ base_name = 'truck' def __init__(self, *args, **kwargs): super(TankerTruck, self).__init__(*args, **kwargs) self.pump_rate = self.env.config.get('tanker.pump_rate', 10) self.avg_travel = self.env.config.get('tanker.travel_time', 600) tank_capacity = self.env.config.get('tanker.capacity', 200) self.tank = Container(self.env, tank_capacity) # This auto_probe() call causes the self.tank Container to be # monkey-patched such that whenever it's level changes, the new level # is noted in the log. self.auto_probe('tank', log={}) # The parent TankerCompany enqueues instructions to this queue. self._instructions = Queue(self.env) # Declare a persistant process to be started at simulation-time. self.add_process(self._dispatch_loop) def dispatch(self, gas_station, done_event): """Append dispatch instructions to the truck's queue.""" return self._instructions.put((gas_station, done_event)) def _dispatch_loop(self): """This is the tanker truck's main behavior. Travel, pump, refill...""" while True: if not self.tank.level: self.info('going for refill') # Desmod simulation environments come equipped with a # random.Random() instance seeded based on the 'sim.seed' # configuration key. travel_time = self.env.rand.expovariate(1 / self.avg_travel) yield self.env.timeout(travel_time) self.info('refilling') pump_time = self.tank.capacity / self.pump_rate yield self.env.timeout(pump_time) yield self.tank.put(self.tank.capacity) self.info('refilled {}L in {:.0f}s'.format( self.tank.capacity, pump_time)) gas_station, done_event = yield self._instructions.get() self.info('traveling to {}'.format(gas_station.name)) travel_time = self.env.rand.expovariate(1 / self.avg_travel) yield self.env.timeout(travel_time) self.info('arrived at {}'.format(gas_station.name)) while self.tank.level and (gas_station.reservoir.level < gas_station.reservoir.capacity): yield self.env.timeout(1 / self.pump_rate) yield gas_station.reservoir.put(1) yield self.tank.get(1) self.info('done pumping') done_event.succeed()
def test_queue_repr(env): queue = Queue(env, name='hi', items=[3, 2, 1]) assert str(queue) == "Queue(name='hi' size=3 capacity=inf)" pri_queue = PriorityQueue(env, capacity=3) assert str(pri_queue) == 'PriorityQueue(name=None size=0 capacity=3)'
def __init__(self, *args, **kwargs): super(CheckoutLane, self).__init__(*args, **kwargs) self.queue = Queue(self.env) self.auto_probe('queue', vcd={}) self.add_process(self.checkout)