def __init__(self, machine_id, last_queue, env, logger,): self.machine_id = machine_id self.last_queue = last_queue self.env = env self.num_of_truck = 0 # parameters self.drive = 5 * 60 self.con_belt_speed = 1 * 1000 # notes: the length of dist in dist table are recorded as (mm) self.nc_speed = 2 * 1000 # notes: the length of dist in dist table are recorded as (mm) self.ir_speed = 2 * 1000 # notes: the length of dist in dist table are recorded as (mm) self.unload_efficiency = 3.6 # request a package every 3.6s # some re for in_out name self.re_reload = re.compile(r"Reload_\w\d") # 3 ways out self.r_small_queue = s_road_q self.i_small_queue = s_int_q self.d_small_queue = s_domestic_q self.r_presort_infeed_queue = r_presort_infeed_q self.i_presort_infeed_queue = i_presort_infeed_q self.d_presort_infeed_queue = d_presort_infeed_q self.r_reload_queue = r_reload_q self.i_reload_queue = i_reload_q self.d_reload_queue = d_reload_q #io rules self.r_dock_unload = r_dock_unload self.r_dock_s_road = r_dock_s_road_rule self.apt_reload = apt_reload self.city_apt = city_apt self.r_dock_r_presort_infeed_rule = r_dock_r_presort_infeed_rule self.r_presort_infeed_rule = r_presort_infeed_rule # dist self.r_dock_dist = r_dock_dist self.nc_dist = nc_dist self.r_dock_r_presort_dist = r_dock_r_presort_dist # logger self.log_record = logger(log_name=f"record_{self.machine_id}") self.log_error = logger(log_name=f"error_{self.machine_id}") # queue for checking and customs self.tmp_queue = simpy.PriorityStore(self.env) # queue for all item self.wait_queue = simpy.PriorityStore(self.env) # event of empty self.empty = self.env.event() # init process # fixme: how many check and customs personals? for i in range(100): self.env.process(self.check_and_customs(name = f"checker_{i}")) self.env.process(self.sorter()) self.env.process(self.empty_queue())
def __init__(self, env, nid, name, area): # It is the constant for which the pheromones will be reduced each time self.env = env self.id = nid self.name = name self.area = area self.areas = [ 'Stavanger', 'Hammerfest', 'Lillehammer-Gjovik', 'Kirkenes', 'Kautokeino', 'Kristiansund', 'Haugesund', 'Svalbard', 'Kristiansand', 'Stord-Haugesund', 'Teknobyen', 'Alta', 'Oslo', 'Osterdalen', 'Sandnessjoen', 'Forde-Volda', 'Bergen', 'Trondheim', 'Bodo', 'Buskerud og Vestfold', 'Volda', 'Telemark', 'Alesund', 'Ostfold', 'Mo', 'Nesna', 'Narvik', 'Tromso', 'Harstad', 'Karasjok', 'Kjeller', 'Molde', 'NLH As', 'kristiansand' ] self.pkt_id = random.randrange(9999999) self.reduce_const = 0.1 # TODO Assign it properly self.pheromone = 1 self.store = simpy.PriorityStore(env) # The queue of pkts in the node self.interfaces = list() self.timeout = 1500 # TODO Assign it properly # It is the time to live in the table self.PAT = PAT() self.PIT = PIT() self.FIB = FIB() self.CS = CS() self.CS.table[area] = CSobject(area, None, 0, self.name) self.action = env.process( self.run()) # starts the run() method as a SimPy process self.action2 = env.process( self.evaporate()) # starts the run() method as a SimPy process self.dist = functools.partial(random.expovariate, 1.0)
def __init__(self, env, name, store, iface=None, rate=1000.0): self.env = env self.name = name self.out_iface = iface self.store = store # Gonna point to the Node, consumer or producer with iface store self.rate = rate self.packets = simpy.PriorityStore(env) self.action = env.process(self.send())
def test_priority_store_item_priority(env): pstore = simpy.PriorityStore(env, 3) log = [] def getter(wait): yield env.timeout(wait) item = yield pstore.get() log.append(item) # Do not specify priority; the items themselves will be compared to # determine priority. env.process((pstore.put(s) for s in 'bcadefg')) env.process(getter(1)) env.process(getter(2)) env.process(getter(3)) env.run() assert log == ['a', 'b', 'c']
def test_priority_store_stable_order(env): pstore = simpy.PriorityStore(env, 3) log = [] def getter(wait): yield env.timeout(wait) _, item = yield pstore.get() log.append(item) items = [object() for _ in range(3)] # Unorderable items are inserted with same priority. env.process((pstore.put(simpy.PriorityItem(0, item)) for item in items)) env.process(getter(1)) env.process(getter(2)) env.process(getter(3)) env.run() # Since the priorities were the same for all items, ensure that items are # retrieved in insertion order. assert log == items
#!/usr/bin/python3 import simpy from collections import namedtuple env = simpy.Environment() issues = simpy.PriorityStore(env) def inspector(env, issues): for issue in [ simpy.PriorityItem('P2', '#0000'), simpy.PriorityItem('P0', '#0001'), simpy.PriorityItem('P3', '#0002'), simpy.PriorityItem('P1', '#0003') ]: yield env.timeout(1) print(env.now, 'log', issue) yield issues.put(issue) def maintainer(env, issues): while True: yield env.timeout(3) issue = yield issues.get() print(env.now, 'repair', issue) _ = env.process(inspector(env, issues)) _ = env.process(maintainer(env, issues)) env.run()
from src.config.io_rule import r_dock_unload from src.config.queues import env from src.simpy_demo_machine import UnloadR, truck_come_controller, check_truck_empty from src.tools.db import get_trucks from src.tools.loggers import get_logger from datetime import datetime if __name__ == '__main__': # timer for real time t1 = datetime.now() # a Environment instance env = env # init trucks queue trucks_dict = get_trucks(istest=False) trucks = simpy.PriorityStore(env) # truck controller : putting trucks truck_come_controller(trucks, trucks_dict) # loading r_unload machines machine_dict = {} for machine_id in r_dock_unload.keys(): unload_machine = UnloadR( machine_id=machine_id, last_queue=trucks, env=env, logger=get_logger, ) machine_dict[machine_id] = unload_machine # add process
import simpy import random as rm def generator_pack(env, pack_queue): i = 0 while True: pack = simpy.PriorityItem(env.now, {'id':env.now, 'name': i}) yield pack_queue.put(pack) print('%d package was put at %d' % (i, env.now)) # print('all packages num: ', len(issues.items)) random_time = rm.randint(3,6) yield env.timeout(random_time) i += 1 def consumer_pack(env, pack_queue): while True: package = yield pack_queue.get() yield env.timeout(1) print('consumer time:', env.now, 'package id:', package.item['id'], 'package name ', package.item['name']) if __name__ == '__main__': rm.seed(42) env = simpy.Environment() queue = simpy.PriorityStore(env) _ = env.process(generator_pack(env, queue)) _ = env.process(consumer_pack(env, queue)) env.run(until=10)
def __init__(self, *args): super(cPRESRPTDispatcher, self).__init__(*args) # override queue attribute with a priority queue self.queue = simpy.PriorityStore(self.env) self.idle_cores = simpy.Store(self.env)
print(f"item: {package} end move at {env.now}") env.exit() def machine(env: simpy.Environment(), last_q: simpy.PriorityStore, next_q: simpy.PriorityStore, machine_id: str): while True: package = yield last_q.get() item = package.item yield env.timeout(PROCESS_TIME) env.process(con_belt_process(env, CON_BELT_TIME, item, next_q)) print( f'Time at {env.now}, machine: {machine_id}, done item {machine_id}' ) if __name__ == '__main__': env = simpy.Environment() last_q = simpy.PriorityStore(env) next_q = simpy.PriorityStore(env) for i in range(100): last_q.put(simpy.PriorityItem(priority=1, item=f'item_{i}')) for i in range(5): env.process(machine(env, last_q, next_q, machine_id=f'm_{i}')) env.run()
default='latency_model.yaml', help='filepath of latency model (default "latency_model.yaml")') args = parser.parse_args() env = simpy.Environment() # Constants # meanInterArrivalTime = 28500 # micro seconds # meanReqSize = 4096 # bytes # meanInterArrivalTime = 4200 # micro seconds # meanReqSize = 16 * 4096 # bytes latencyModel = LatencyModel4K(args.model) # OSD queue(s) # Add capacity parameter for max queue lengths queueDepth = 48 osdQ1 = simpy.PriorityStore(env, capacity=queueDepth) osdQ2 = simpy.PriorityStore(env, capacity=queueDepth) # osdQ = simpy.Store(env) # infinite capacity # KV queue (capacity translates into initial batch size) kvQ = simpy.Store(env, 1) # OSD client(s), each with a particular priority pushing request into a particular queue # random size and speed osd client # osdClientPriorityOne = RandomOSDClient(meanInterArrivalTime * 2, meanReqSize, 1, osdQ1) # osdClientPriorityTwo = RandomOSDClient(meanInterArrivalTime * 2, meanReqSize, 2, osdQ1) # 4k osd client workload generator osdClientPriorityOne = OsdClientBench4K(4096.0, 1) osdClientPriorityTwo = OsdClientBench4K(4096.0, 2)