import threading import time import multiprocessing import importlib.util from multiprocessing.managers import BaseManager from myutils.ConfigManager import myCongif from myutils.MyLogger_logger import LogHandler from core.ACLModelManager import ACLModeManger from core.DataStruct import ModelinData,ModeloutData from threading import Lock #2024-10-14model处理调整为独立子进程 def model_process(device,model,model_platform,m_p_status,brun,in_mq,out_mq): # 初始化模型运行资源 context = None if model_platform == "acl": # ACL线程中初始化内容 context = ACLModeManger.pro_init_acl(device) # 初始化acl资源，并创建context # 初始化模型资源 -- 加载模型文件 ret = model.init_acl_resource() # 加载和初始化离线模型文件--om文件 if not ret: print("初始化模型资源出错，退出线程！") m_p_status.value = 2 return #执行工作 m_p_status.value = 1 use_time = 0 icount = 0 while brun.value: try: inData = in_mq.get(timeout=0.1) #空时-block，直到有值 #(self,channel_id,img,image,scale_ratio, pad_size): except: #print("in_mq_空") continue if inData: #print(f"{time.time()}--{inData.channel_id}--数据取出进行处理！") s_time = time.time() outputs = model.execute([inData.img,])#创建input，执行模型，返回结果 --失败返回None e_time = time.time() outdata = ModeloutData(inData.image,inData.scale_ratio,inData.pad_size,outputs,inData.channel_id) del inData.img #结果输出 if out_mq.full(): tmp = out_mq.get() #print("model_输出mq满！") del tmp out_mq.put(outdata) # 需要确保out_mq只有在这里put # else: #正常情况不会执行到该条件 # time.sleep(0.01) icount += 1 use_time += (e_time - s_time) if icount == 500: avg_time = use_time / 500 print(f"model_process耗时--{avg_time}秒") use_time = 0 icount = 0 #结束进程，释放资源 m_p_status.value = 0 while not in_mq.empty(): try: in_mq.get_nowait() # Get without blocking except Exception as e: break # In case of any unexpected errors # 反初始化 if model_platform == "acl": try: model.release() # 释放模型资源资源 # 删除模型对象 del model # 释放ACL资源 ACLModeManger.pro_del_acl(device,context) except Exception as e: print(e) class ModelNode: def __init__(self,device,model_path,ch_max_count=1): self.device = device self.model_path = model_path self.channel_id = [] #channel_id_list self.model = None #模型对象 self.ch_max_count = ch_max_count self.ch_count = 0 #关联启动的通道数量 self.count_Lock = Lock() #count的维护锁 self.model_platform = myCongif.get_data("model_platform") self.logger = LogHandler().get_logger("ModelNode") #分发线程相关 self.model_out_th = None self.channel_dict = {} self.cdict_Lock = Lock() self.in_mq_Lock = Lock() self.last_in_c_id = 0 #独立进程方案--共享参数 self.process = None self.imq_count = ch_max_count * 20 #一个通道20帧缓冲区间 self.in_mq = multiprocessing.Queue(maxsize=self.imq_count) self.out_mq = multiprocessing.Queue(maxsize=self.imq_count) #调整结构，多线程（预处理）-》in_mq-子进程-out_mq-》线程分发outdata->多线程（后处理） self.brun = multiprocessing.Value('b',True) #brun.value = False,brun.value = True self.m_p_status = multiprocessing.Value('i',0) def __del__(self): pass def _import_model(self, model_path, threshold=0.5, iou_thres=0.5): ''' 根据路径，动态导入模块 :param model_path: 模块路径 :param threshold: 置信阈值 :param iou_thres: iou阈值 :return: ''' try: module_path = model_path.replace("/", ".").rsplit(".", 1)[0] print(module_path) # 动态导入模块 module = importlib.import_module(module_path) # 从模块中获取指定的类 Model = getattr(module, "Model") # 使用 Model 类 model_instance = Model(model_path, threshold, iou_thres) return model_instance except ModuleNotFoundError as e: print(f"Module not found: {e}") return None except AttributeError as e: print(f"Class not found in module: {e}") return None except Exception as e: print(f"An unexpected error occurred: {e}") return None def pro_add_data(self,data): # try: # self.in_mq.put(data,timeout=0.1) # except multiprocessing.queues.Full: # print("mdel_inmq输入满！") # del data with self.in_mq_Lock: if self.ch_count>1 and self.last_in_c_id == data.channel_id: return self.last_in_c_id = data.channel_id if self.in_mq.full(): tmp = self.in_mq.get() #print("mdel_inmq输入满！") del tmp self.in_mq.put(data) # 需要确保out_mq只有在这里put def _modle_th(self): '''根据channel_id分发out_data到out_mq''' s_time = time.time() icount = 0 while self.brun.value: try: outdata = self.out_mq.get(timeout=0.1) except: continue with self.cdict_Lock: if outdata.channel_id in self.channel_dict: self.channel_dict[outdata.channel_id].myappend(outdata) #后面就交给后处理线程了 else: print(f"{outdata.channel_id}不在channel_dict里面") # icount += 1 # if icount ==500: # e_time = time.time() # use_time = (e_time-s_time) /500 # print(f"{self.channel_id}_modle_th耗时--{use_time}秒") # s_time = time.time() # icount = 0 #2024-10-14调整为独立进程执行 -- 一个线程一个MQ MyDeque def start_model_th(self,channel_id,out_mq): with self.count_Lock: with self.cdict_Lock: if channel_id in self.channel_dict: print(f"{channel_id}已经在channel_dict内") return #这个可以删除老的，新增新的--后续验证，若需要则进行修改 self.channel_dict[channel_id] = out_mq #增加一个记录 print(f"新增一个channel节点--{channel_id}") if self.ch_count == 0: #第一次启动--需要启动处理线程和进程 #加载自定义模型文件 self.model = self._import_model(self.model_path) # 动态加载模型处理文件py --置信阈值一直没使用 if not self.model: self.logger.error("自定义模型文件加载失败，不启动model子进程") self.m_p_status.value = 2 return self.brun.value = True #创建outMQ的分发线程 self.model_out_th = threading.Thread(target=self._modle_th) self.model_out_th.start() # 创建子进程 self.process = multiprocessing.Process(target=model_process, args=(self.device,self.model,self.model_platform, self.m_p_status,self.brun,self.in_mq,self.out_mq)) self.process.start() self.ch_count += 1 #有通道调用一次就加一 def stop_model_th(self,channel_id): with self.count_Lock: with self.cdict_Lock: if channel_id in self.channel_dict: del self.channel_dict[channel_id] self.ch_count -= 1 if self.ch_count == 0: #所有通道结束 self.brun.value = False self.model_out_th.join() #等待线程结束 self.model_out_th = None self.process.join() #等待子进程结束 self.process = None