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)