zfbox/core/ModelNode.py

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