def run(self, input_file, output_file):
assert (type(output_file) == str)
assert (type(input_file) == str)
self._init()
self.config.input_file = input_file
self.config.output_file = output_file
file_reader = Process(target=self._engine_preprocess,
args=(input_file, ))
file_reader.deamon = True
file_reader.start()
runtime_list = []
for num_gpu in self.config.gpu:
runtime = Process(target=self._engine_model, args=(num_gpu, ))
runtime.deamon = True
runtime.start()
runtime_list.append(runtime)
file_writer = Process(target=self._engine_postprocess,
args=(output_file, ))
file_writer.deamon = True
file_writer.start()
# Terminate
file_reader.join()
runtime.join()
file_writer.join()
self.logger.warning("ALL JOBS DONE")
def main():
global request_queue
summoner_name = ''
while len(summoner_name) == 0:
summoner_name = input('Summoner Name: ')
platform_slug = input('Platform slug (default=na1): ')
if len(platform_slug) == 0:
platform_slug = 'na1'
platform_slug = platform_slug.strip().lower()
start_sync_manager()
with open(config_path, 'r') as f:
config = json.loads(f.read())
server = http.server.HTTPServer((config['server']['host'], config['server']['port'] + 1),
MyResponseListener)
summoner_by_name = 'https://{slug}.api.riotgames.com/lol/summoner/v3/summoners/by-name/{name}'
start_url = summoner_by_name.format(slug=platform_slug, name=summoner_name)
request_queue.put((start_url, "start"))
scenario_args = (config, platform_slug, request_queue, response_queue,
gamemode_summaries, champion_summaries, requested_matches)
sm = Process(target=scenario_manager, args=scenario_args, name='Scenario_Manager')
sm.deamon = True
sm.start()
try:
server.serve_forever()
except KeyboardInterrupt:
print('Stopping scenario...')
def fork_train_process():
"""创建守护进程，接收主进程训练消息，存放到队列中，依次对模型进行训练
"""
logger = logging.getLogger("ProcessTrain")
def handle_message(msg):
"""处理主进程发送来的消息
Args:
msg (dict): 待处理的消息，robot_code，version两个参数
"""
# 训练nlu模型
train_robot(**msg)
# 通知主进程更新模型
internal_push_nlu(**msg)
# 通知小语平台训练成功
notify_training_complete(**msg)
def consummer():
"""
队列消费者
"""
while True:
msg = global_queue.get()
try:
handle_message(msg)
except Exception:
logger.error(msg)
logger.error(traceback.format_exc())
process = Process(target=consummer)
process.deamon = True
process.start()
return process
def upload(self):
if self.sync_dirs:
for sync_dir in self.sync_dirs:
sync_dir = sync_dir.strip(".")
for dirName, subdirList, fileList in os.walk(
"%s%s" % (self.base, sync_dir)):
thisdir = "".join(dirName.rsplit(self.base)).strip("/")
fileList = [
os.path.join(dirName, filename)
for filename in fileList
]
if self.excludes:
for ignore in self.excludes:
fileList = [
n for n in fileList
if not fnmatch.fnmatch(n, ignore)
]
count = 0
for fname in fileList:
dest_key = self.generate_dest_key(fname, thisdir)
if os.name != 'nt':
rv = Process(target=self.skip_or_send,
args=(fname, dest_key))
rv.deamon = True
rv.start()
if count % 20 == 0:
rv.join()
else:
self.skip_or_send(fname, dest_key)
count += 1
if 'rv' in vars():
rv.join()
def run_interactive_learning(stories: Text = None,
finetune: bool = False,
skip_visualization: bool = False,
server_args: Dict[Text, Any] = None,
additional_arguments: Dict[Text, Any] = None):
"""Start the interactive learning with the model of the agent."""
server_args = server_args or {}
if not skip_visualization:
p = Process(target=start_visualization, args=("story_graph.dot", ))
p.deamon = True
p.start()
else:
p = None
app = run.configure_app(enable_api=True)
endpoints = AvailableEndpoints.read_endpoints(server_args.get("endpoints"))
# before_server_start handlers make sure the agent is loaded before the
# interactive learning IO starts
if server_args.get("core"):
app.register_listener(
partial(run.load_agent_on_start, server_args.get("core"),
endpoints, server_args.get("nlu")), 'before_server_start')
else:
app.register_listener(
partial(train_agent_on_start, server_args, endpoints,
additional_arguments), 'before_server_start')
_serve_application(app, stories, finetune, skip_visualization)
if not skip_visualization:
p.terminate()
p.join()
def main(cfg):
# LIVE CONFIGURATION - WHAT TO RECORD
extras=retrieveRTPMonitored()
mmanage = multiprocessing.Manager()
statsDict = mmanage.dict()
framesQueue=Queue()
collectorProc=Process(target=startCollector, args=(framesQueue,cfg['general']['interface']))
collectorProc.daemon=True
collectorProc.start()
print("[",collectorProc.pid,"] Started main thread")
time.sleep(3)
viewStoreProc=Process(target=viewAndStore, args=(statsDict,cfg['dbconf']['dbfile'],))
parsersProc=Process(target=AnalyzerThreads,args=(cfg['general']['num_of_processes'],framesQueue,statsDict,mmanage,cfg['monitor']['ports']))
parsersProc.deamon=True
parsersProc.start()
print("[",parsersProc.pid,"] Started frame parsers")
viewStoreProc.start()
print("[",viewStoreProc.pid,"] Started live view stats and dbcollector")
parsersProc.join()
viewStoreProc.join()
def _transform_parallel(self):
if self.num_workers == None:
num_workers = multiprocessing.cpu_count()
# partition the data
shape = self.train_data.shape
row_num = shape[0] # suppose dimension as N.C.W.H
rows_per_worker = ceil(row_num / num_workers)
workers = []
index_list = list(range(0, row_num, rows_per_worker))
for n, start in enumerate(index_list):
if n == len(index_list) - 1:
end = row_num
else:
end = index_list[n + 1]
args = (self._shm_train_raw, shape, (start, end), self.transform)
a = np.ctypeslib.as_array(self._shm_train_raw.get_obj())
a = a.reshape(self.train_data.shape)
proc = Process(target=_transform_proc, args=args)
proc.deamon = True
proc.start()
workers.append(proc)
# wait for all subprocess finish
for proc in workers:
proc.join()
# reshape
self._shm_train_nda = self._shm_train_nda.reshape(self.final_shape)
def calculate_quality_list(self, voi, gantry, couch, calculate_from=0, stepsize=1.0, avoid=[], gradient=True):
""" TODO: Documentation
"""
q = Queue(32767)
process = []
d = voi.get_voi_cube()
d.cube = np.array(d.cube, dtype=np.float32)
voi_cube = DensityProjections(d)
result = []
for gantry_angle in gantry:
p = Process(
target=self.calculate_angle_quality_thread,
args=(voi, gantry_angle, couch, calculate_from, stepsize, q, avoid, voi_cube, gradient))
p.start()
p.deamon = True
process.append(p)
if len(process) > 2:
tmp = q.get()
result.append(tmp)
for p in process:
if not p.is_alive():
process.remove(p)
while not len(result) == len(gantry) * len(couch):
tmp = q.get()
result.append(tmp)
return result
def start_conn_process():
# Create device info here as it may change after restart.
config = {
"digest" : "serial",
"port" : self.mbed.port,
"baudrate" : self.mbed.serial_baud,
"program_cycle_s" : self.options.program_cycle_s,
"reset_type" : self.options.forced_reset_type,
"target_id" : self.options.target_id,
"serial_pooling" : self.options.pooling_timeout,
"forced_reset_timeout" : self.options.forced_reset_timeout,
"sync_behavior" : self.options.sync_behavior,
"platform_name" : self.options.micro,
"image_path" : self.mbed.image_path,
}
if self.options.global_resource_mgr:
grm_module, grm_host, grm_port = self.options.global_resource_mgr.split(':')
config.update({
"conn_resource" : 'grm',
"grm_module" : grm_module,
"grm_host" : grm_host,
"grm_port" : grm_port,
})
# DUT-host communication process
args = (event_queue, dut_event_queue, config)
p = Process(target=conn_process, args=args)
p.deamon = True
p.start()
return p
def start_conn_process():
# DUT-host communication process
args = (event_queue, dut_event_queue, config)
p = Process(target=conn_process, args=args)
p.deamon = True
p.start()
return p
def start_conn_process():
# Create device info here as it may change after restart.
config = {
"digest": "serial",
"port": self.mbed.port,
"baudrate": self.mbed.serial_baud,
"program_cycle_s": self.options.program_cycle_s,
"reset_type": self.options.forced_reset_type,
"target_id": self.options.target_id,
"serial_pooling": self.options.pooling_timeout,
"forced_reset_timeout": self.options.forced_reset_timeout,
"sync_behavior": self.options.sync_behavior,
"platform_name": self.options.micro,
"image_path": self.mbed.image_path,
}
if self.options.global_resource_mgr:
grm_module, grm_host, grm_port = self.options.global_resource_mgr.split(
':')
config.update({
"conn_resource": 'grm',
"grm_module": grm_module,
"grm_host": grm_host,
"grm_port": grm_port,
})
# DUT-host communication process
args = (event_queue, dut_event_queue, config)
p = Process(target=conn_process, args=args)
p.deamon = True
p.start()
return p
def calculate_quality_list(self,
voi,
gantry,
couch,
calculate_from=0,
stepsize=1.0,
avoid=[],
gradient=True):
""" TODO: Documentation
"""
q = Queue(32767)
process = []
d = voi.get_voi_cube()
d.cube = np.array(d.cube, dtype=np.float32)
voi_cube = DensityProjections(d)
result = []
for gantry_angle in gantry:
p = Process(target=self.calculate_angle_quality_thread,
args=(voi, gantry_angle, couch, calculate_from,
stepsize, q, avoid, voi_cube, gradient))
p.start()
p.deamon = True
process.append(p)
if len(process) > 2:
tmp = q.get()
result.append(tmp)
for p in process:
if not p.is_alive():
process.remove(p)
while not len(result) == len(gantry) * len(couch):
tmp = q.get()
result.append(tmp)
return result
def worker_proc(tur_arg=None, authdata=None, sleeper=None, multipools=None, work=None):
for wp in range(multipools):
j = Process(target=uploader.UploadAction, args=(tur_arg, authdata, work))
j.deamon = True
j.start()
for i in xrange(multipools):
work.put(None)
def export_bodies(self, folder, width=None, height=None, cX=None, cY=None, workers=5):
"""Parallel Implementation of bodies Export"""
file_format = "{:09d}_{:09d}.jpg"
video_name, ext = os.path.splitext(self.video_name)
os.makedirs(folder, exist_ok=True)
img_folder = os.path.join(folder, video_name)
# cvs_filename = os.path.join(folder, "dataset.csv")
json_filename = os.path.join(folder, video_name + ".json")
os.makedirs(img_folder, exist_ok=True)
body_info = []
video_size = len(self)
chunksize = video_size//workers
lock = Lock()
ws = list()
pbar = list()
for w in range(workers - 1):
start = w * chunksize
end = (w + 1) * chunksize
pbar.append(tqdm(total=chunksize))
p = Process(target=process_video, args=(self[start:end], self.video_path, start, end, img_folder, file_format, lock, pbar[w]))
p.deamon = True
ws.append(p)
p.start()
start = (workers - 1)* chunksize
end = len(self)
pbar.append(tqdm(total=end-start))
p = Process(target=process_video, args=(self[start:end], self.video_path, start, end, img_folder, file_format, lock, pbar[workers -1]))
p.deamon = True
ws.append(p)
p.start()
for w in ws:
w.join()
self.save(json_filename)
return
def confirm(self): v = [self.block1.get(), self.block2.get()] # main(v[0], v[1]) p = Process( target=self.commu.decor, args=(new_mian, v[0], v[1], "10.1") ) p.deamon = True p.start() self.commu.process_communication(self.major_msgframe)
def bus_watcher():
data = request.json
route = data['route']
dep_station = data['dep_station']
at = data['at']
t = Process(target=notify_rt_oneshot, args=(route, dep_station, at))
t.deamon = True
t.start()
return "Enabled notify for bus %s from %s when it's at %s" % (
route, dep_station, at)
def __init__(self):
print("Making Hexapod ready, please wait..")
ps3 = PlaystationService()
if ps3.ps3Connected:
p2 = Process(target=ps3.joystickcontrole)
p2.deamon = True
p2.start()
hexapod = Hexapod()
hexapod.boot_up()
time.sleep(2)
print("Hexapod is ready to go.")
def spawnProcesses(nbr,target,args):
processes=[]
if __name__ == '__main__':
processes = []
for x in range(nbr):
p = Process(target=target,args=args)
p.deamon = True
processes.append(p)
return processes
def __init__(self):
print("Making TubberCar ready, please wait..")
try:
mqtt = MqttService()
p1 = Process(target=mqtt.connectandsubscribe,
args=(
self.subscribeTB,
'TubberCar',
))
p1.deamon = True
p1.start()
time.sleep(5)
ps3 = PlaystationService()
if (ps3.ps3Connected):
p2 = Process(target=ps3.joystickcontrole)
p2.deamon = True
p2.start()
time.sleep(2)
except KeyboardInterrupt:
print("Exiting program.")
p1.stop()
def start_conn_process():
# Create device info here as it may change after restart.
config = {
"digest" : "serial",
"port" : self.mbed.port,
"baudrate" : self.mbed.serial_baud,
"program_cycle_s" : self.options.program_cycle_s,
"reset_type" : self.options.forced_reset_type
}
# DUT-host communication process
args = (event_queue, dut_event_queue, self.prn_lock, config)
p = Process(target=conn_process, args=args)
p.deamon = True
p.start()
return p
def newAlarm(self,seconds,name):
if self.alarmList[name]!=None:
if self.alarmList[name].is_alive():
return False
ala=Process(target=startout, args=(seconds,name))
ala.deamon=True
ala.start()
self.alarmList[name]=ala
print '--------------alarmList Below-------------'
for each in self.alarmList.keys():
if self.alarmList[each]!=None:
print each
print self.alarmList[each].pid
print '--------------alarmList above-------------'
return True
def start_conn_process():
# Create device info here as it may change after restart.
config = {
"digest": "serial",
"port": self.mbed.port,
"baudrate": self.mbed.serial_baud,
"program_cycle_s": self.options.program_cycle_s,
"reset_type": self.options.forced_reset_type
}
# DUT-host communication process
args = (event_queue, dut_event_queue, self.prn_lock, config)
p = Process(target=conn_process, args=args)
p.deamon = True
p.start()
return p
def main_funtion(path, core, res):
"""
path: 包含mxd的文件夹
study_book{Int}: 开启的多进程数 推荐3~4，新电脑或者高性能CPU可以选7甚至更高
res{Int}: 出图分辨率
:return: NONE
"""
sets_lists, msg = address_clip(path, core)
for a_msg in msg: # 读取分组信息
print(a_msg + ";\n")
for set_li in sets_lists:
time.sleep(0.5)
# 开启多进程
p = Process(target=export_jpeg, args=(set_li, res))
p.deamon = True
p.start()
def add_module(self, module_fn):
remote, work_remote = Pipe()
p = Process(target=self.run,
args=(work_remote, remote, module_fn, self._managed_memory,
self._seed))
p.deamon = True
p.start()
work_remote.close()
self._remotes.append(remote)
self._ps.append(p)
self._train_res = None
return len(self._ps) - 1
def run(self):
manager = Manager()
result = manager.list()
processes = []
for i in range(self.max_process):
proc = Process(target=self._worker, args=(result, ))
proc.deamon = True
processes.append(proc)
for proc in processes:
proc.start()
for proc in processes:
proc.join()
return result
def Demo():
if __name__ == "__main__":
command_queue = Queue()
t = Process(target=_mp_worker, args=(command_queue,))
t.deamon = True
t.start()
try:
while True:
command_queue.put_nowait([SCANCODE.W, 0.080, 0.1])
command_queue.put_nowait([SCANCODE.W, 0.080, 0.5])
command_queue.put_nowait([SCANCODE.A, 0.251, 0.5])
command_queue.put_nowait([SCANCODE.D, 0.251, 0.5])
command_queue.put_nowait([SCANCODE.S, 0.551, 0.5])
time.sleep(5)
except KeyboardInterrupt:
print("Goodbye!")
def multi():
processes = []
dataset = Queue()
datasetProducer = Process(target=put_dataset, args=(dataset, ))
datasetProducer.daemon = True
processes.append(datasetProducer)
datasetProducer.start()
for core in range(4):
work = Process(target=worker, args=(dataset, ))
work.deamon = True
processes.append(work)
work.start()
try:
datasetProducer.join()
except KeyboardInterrupt:
for process in processes:
process.terminate()
print('\n\n------------------------\nALL PROCESSES TERMINATED\n')
def fileserver(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
Port = int(Parameters["Mode3"])
Domoticz.Log("Starting file server on port " + str(Port))
Filelocation = Parameters["Mode2"]
os.chdir(Filelocation)
Handler = http.server.SimpleHTTPRequestHandler
socketserver.TCPServer.allow_reuse_address = True
server = socketserver.TCPServer(("", Port), Handler)
p = Process(target=server.serve_forever)
p.deamon = True
p.start()
Domoticz.Log("Files in the '" + Filelocation +
"' directory are now available on port " + str(Port))
except socket.error as e:
if e.errno == errno.EADDRINUSE:
Domoticz.Log("Port " + str(Port) + " is already in use")
else:
senderror(e)
def submit(self, func: Callable, fn_args: Any, p_kwargs: Dict,
timeout: float, callback_timeout: Callable[[Any],
Any], daemon: bool):
"""
Submits a callable to be executed with the given arguments.
Schedules the callable to be executed as func(*args, **kwargs) in a new
process.
:param func: the function to execute
:param fn_args: the arguments to pass to the function. Can be one argument
or a tuple of multiple args.
:param p_kwargs: the kwargs to pass to the function
:param timeout: after this time, the process executing the function
will be killed if it did not finish
:param callback_timeout: this function will be called with the same
arguments, if the task times out.
:param daemon: run the child process as daemon
:return: the result of the function, or None if the process failed or
timed out
"""
p_args = fn_args if isinstance(fn_args, tuple) else (fn_args, )
queue = Queue()
p = Process(target=self._process_run,
args=(
queue,
func,
fn_args,
),
kwargs=p_kwargs)
if daemon:
p.deamon = True
p.start()
p.join(timeout=timeout)
if not queue.empty():
return queue.get()
if callback_timeout:
callback_timeout(*p_args, **p_kwargs)
if p.is_alive():
p.terminate()
p.join()
def main():
#Setup queue data structures for relayed data
freeze_support()
q_1_2 = Queue()
q_2_1 = Queue()
kill_flag = Event()
#Get args
bind1, bind2, conn1, conn2, v, t = get_args()
#Setup relay
if bind1 and bind2:
host1 = Process(target=bind_relay, args=(bind1, q_2_1, q_1_2, t, kill_flag))
host2 = Process(target=bind_relay, args=(bind2, q_1_2, q_2_1, t, kill_flag))
elif conn1 and conn2:
host1 = Process(target=connect_relay, args=(conn1, q_2_1, q_1_2, t, kill_flag))
host2 = Process(target=connect_relay, args=(conn2, q_1_2, q_2_1, t, kill_flag))
else:
host1 = Process(target=bind_relay, args=(bind1, q_2_1, q_1_2, t, kill_flag))
host2 = Process(target=connect_relay, args=(conn1, q_1_2, q_2_1, t, kill_flag))
try:
#Start relay
host1.daemon=True
host2.deamon=True
host1.start()
host2.start()
while True:
if kill_flag.is_set():
#We've been told to die by another thread.
print("[!] - Terminating relays. Please wait.")
sleep(3)
exit(0)
sleep(1)
except KeyboardInterrupt:
print("\n[!] - Interrupted - please wait.")
kill_flag.set()
sleep(3)
exit(0)
except Exception as e:
print("Exception in main : {}".format(e))
exit(0)
plt.set_cmap("jet")
if f0 > 0:
extent = [ (f0 - samp_rate/2)/1e6,
(f0 + samp_rate/2)/1e6,
1e3 * len(data) * float(fft_step) / samp_rate,
0]
im = plt.imshow(data,interpolation='bilinear', extent=extent, aspect='auto')
else:
im = plt.imshow(data,interpolation='bilinear', aspect='auto')
plt.colorbar(im)
# dump
if png != "":
plt.savefig(png,dpi=100)
if npy != "":
np.save(npy, data)
if show:
#plt.show()
#raw_input("press return to continue")
#plt.ion()
plt.draw()
plt.pause(.1)
plot_queue = Queue()
p = Process(target=plot_process)
p.deamon = True
p.start()
continue if port == 0: print "[MANAGER] Error in assigning ports" continue print "[MANAGER] Received simulation with sim_id=" + sim_id + ", starting now on port " + str(port) starter = Starter() starter_thread = Thread(target=starter.main, args=(sim_id, port, ports, semaphore)) starter_thread.start() class Tests: def __init__(self, t): print "[HANDLE TESTS] Thread started" self.tests = t def handle_tests(self): while 1: team_name, agent_name = self.tests.get(block=True) print "[TESTS] Received test request with agent_name: " + agent_name + " team_name:" + team_name + ", starting now.." test = Test() test_thread = Thread(target=test.run, args=(team_name, agent_name,)) test_thread.start() test_thread.join() if __name__ == "__main__": manager = Manager() manager_thread = Process(target=manager.main) manager_thread.deamon = True manager_thread.start() manager_thread.join()
def multiprocess_dama(sid, img_data, code_type):
log_name = 'multiprocess_dama'
data = {'sid': sid}
parent_conn, child_conn = Pipe()
begin_time = time.time()
proccess_flag = 0
p1 = Process(target=dama_proccess,
args=(
sid,
img_data,
code_type,
proccess_flag,
child_conn,
)) #申请子进程
p1.deamon = True
p1.start() #运行进程
proccess_flag = 1
print('A进程启动完毕')
data['p1'] = 'p1'
data['A进程启动完毕'] = 'A进程启动完毕'
while True:
end_time = time.time()
# print (end_time-begin_time)
if end_time - begin_time > 20 and proccess_flag == 1:
p2 = Process(target=dama_proccess,
args=(
sid,
img_data,
code_type,
proccess_flag,
child_conn,
)) #申请子进程
p2.deamon = True
p2.start() #运行进程
proccess_flag = 2
print('B进程启动完毕')
data['B进程启动完毕'] = 'B进程启动完毕'
data['p2'] = 'p2'
if end_time - begin_time > 40 and proccess_flag == 2:
p3 = Process(target=dama_proccess,
args=(
sid,
img_data,
code_type,
proccess_flag,
child_conn,
)) #申请子进程
p3.start() #运行进程
p3.deamon = True
proccess_flag = 3
print('C进程启动完毕')
data['C进程启动完毕'] = 'C进程启动完毕'
data['p3'] = 'p3'
data['proccess_flag'] = proccess_flag
if parent_conn.poll():
task = parent_conn.recv()
if len(task) > 2:
print('收到管道信息'.format(task))
data['收到管道信息'] = task
parent_conn.close()
child_conn.close()
logger(log_name, task[0], task[1], **data)
return task
if end_time - begin_time > 60:
break
time.sleep(1)
print(end_time - begin_time)
logger(log_name, 'crawl_error', '打码平台超时', **data)
return 'crawl_error', u"打码平台超时", "", None
to_write = JoinableQueue()
def writer(q):
# Call to_write.get() until it returns None
has_header_dict = {}
for fname, df in iter(q.get, None):
if fname in has_header_dict:
df.to_csv(fname, header=False, mode="a")
else:
df.to_csv(fname, header=True, mode="w")
has_header_dict[fname] = True
q.task_done()
q.task_done()
write_thread = Process(target=writer, args=(to_write, ))
write_thread.deamon = True
write_thread.start()
def process_date(date, write_header=False, write_queue=to_write):
date_files = glob.glob(args.file + "/*_" + str(date) +
".feather") # [:NFILES]
# Read feather files
run_data = [pd.read_feather(f) for f in date_files]
tot_df = pd.concat(run_data)
# force GC to free up lingering cuda allocs
del run_data
gc.collect()
# Get start date of simulation
try:
time.sleep(600)
except:
if cfg['global']['verbose']:
print "Have to end the Sync loop... :("
return
#Including Website
execfile('./website/main.py')
#webservice = Process(target=service_web)
#webservice.deamon = True
#webservice.start()
#if cfg['global']['verbose']:
# print "Serverstarted. You can use your browser to configure: http://%s:%s" % \
# (cfg['webserver']['ip'], cfg['webserver']['port'])
#
syncservice = Process(target=service_sync)
syncservice.deamon = True
syncservice.start()
def quit(signum, frame):
if cfg['global']['verbose']:
print "\nThanks for using always Backup"
try:
sys.exit(0)
except:
pass
signal.signal(signal.SIGINT, quit)
while True:
log.info("Hello from process one")
time.sleep(1)
def process_two():
logger.worker_configurer(self.settings['LOGGER'])
log = logging.getLogger('ShipShape')
while True:
msg = "Hello hello from process two"
print(msg)
log.info(msg)
time.sleep(1)
p1 = Process(target=process_one)
p2 = Process(target=process_two)
logging_proc = Process(name="Logger_Listener",
target=logger.LoggerListener,
args=(q, ))
logging_proc.deamon = True
logging_proc.start()
p1.daemon = True
p2.daemon = True
p1.start()
p2.start()
while True:
time.sleep(1)
def main(running):
server = NetServer(
name='act',
address=const.LOCAL_ADDR,
port=const.LOCAL_PORT,
buffer_size=const.QUEUE_SIZE,
)
server_proc = Process(target=server.run)
server_proc.start()
client = NetClient(
client_name='act',
server_addr=const.SERVER_ADDR,
buffer_size=const.QUEUE_SIZE,
)
if const.UPLOAD_DATA:
client_proc = Process(target=client.run)
client_proc.start()
data_savers = {}
tube_queue = Q(const.QUEUE_SIZE)
act_spatial_queue = Q(const.QUEUE_SIZE)
act_nn_queue = Q(const.QUEUE_SIZE)
act_comp_queue = Q(const.QUEUE_SIZE)
filter_queue = Q(const.QUEUE_SIZE)
tm = ServerPktManager(
in_queue=server.data_queue,
out_queue=tube_queue,
track_list=const.TRACK_LABELS,
overlap_list=const.ATTACH_LABELS,
)
tm_proc = Thread(target=tm.run)
tm_proc.deamon = True
tm_proc.start()
spatial_act = SpatialActDetector(
in_queue=tube_queue,
out_queue=act_spatial_queue,
)
spatial_proc = Process(target=spatial_act.run)
spatial_proc.deamon = True
spatial_proc.start()
nn_act = NNActDetector(
in_queue=act_spatial_queue,
out_queue=act_nn_queue,
model_path=const.NN_ACT_MODEL_PATH,
batch_size=const.NN_BATCH,
tube_size=const.TUBE_SIZE,
filter_queue=filter_queue,
)
nn_act_proc = Process(target=nn_act.run)
nn_act_proc.deamon = True
nn_act_proc.start()
comp_act = CompActDetector(
in_queue=act_nn_queue,
out_queue=act_comp_queue,
filter_queue=filter_queue,
)
comp_act_proc = Process(target=comp_act.run)
comp_act_proc.deamon = True
comp_act_proc.start()
out_queue = act_comp_queue
print('server starts')
while running[0]:
server_pkt = out_queue.read()
if server_pkt is None:
sleep(0.01)
continue
cid = server_pkt.cam_id
if cid not in data_savers:
data_savers[cid] = DataWriter(file_path=RES_FOLDER +
'{}.npy'.format(cid))
print('creat data_saver for video {}'.format(cid))
logging.info("Cam-{}, Frame-{}, Acts-{}".format(
server_pkt.cam_id, server_pkt.get_first_frame_id(),
server_pkt.get_action_info()))
logging.info("--------------------------------")
data_pkts = server_pkt.to_data_pkts()
for p in data_pkts:
if const.UPLOAD_DATA:
client.send_data(p)
if const.SAVE_DATA:
data_savers[cid].save_data(frame_id=p.frame_id, meta=p.meta)
if const.SAVE_DATA:
for cid in data_savers:
data_savers[cid].save_to_file()
server.stop()
print("server finished!")
