feat: support load Unload Res

Author: whybeyoung

pyWrapper.cpp

@@ -119,6 +119,10 @@ PyWrapper::PyWrapper() {
     _wrapperOnceExec = _obj.attr("wrapperOnceExec");
     _wrapperOnceExecAsync = _obj.attr("wrapperOnceExecAsync");
     _wrapperError = _obj.attr("wrapperError");
+
+    // 个性化
+    _wrapperLoadRes = _obj.attr("wrapperLoadRes");
+    _wrapperUnloadRes = _obj.attr("wrapperUnloadRes");
     // stream support
     _wrapperCreate = _obj.attr("wrapperCreate");
     _wrapperWrite = _obj.attr("wrapperWrite");
@@ -153,6 +157,8 @@ PyWrapper::~PyWrapper() {
     _wrapperCreate.release();
     _wrapperWrite.release();
     _wrapperRead.release();
+    _wrapperUnloadRes.release();
+    _wrapperLoadRes.release();
     pybind11::gil_scoped_release release;
 }
 
@@ -174,6 +180,9 @@ void PyWrapper::ReloadWrapper() {
     _wrapperCreate = _obj.attr("wrapperCreate");
     _wrapperWrite = _obj.attr("wrapperWrite");
     _wrapperRead = _obj.attr("wrapperRead");
+
+    _wrapperLoadRes = _obj.attr("wrapperLoadRes");
+    _wrapperUnloadRes = _obj.attr("wrapperUnloadRes");
     pybind11::gil_scoped_release release;
 }
 
@@ -240,15 +249,15 @@ int PyWrapper::wrapperFini() {
 }
 
 int PyWrapper::wrapperOnceExec(const char *usrTag, std::map <std::string, std::string> params, DataListCls reqData,
-                               pDataList *respData, std::string sid, wrapperCallback cb) {
+                               pDataList *respData, std::string sid, wrapperCallback cb, unsigned int  psrId ) {
     SetSidUsrTag(sid, usrTag);
     try {
         if (cb != nullptr) {
             SetSidCallBack(cb, sid);
         }
         params["sid"] = sid;
         // 执行python exec 推理
-        py::object r = _wrapperOnceExec(params, reqData, usrTag);
+        py::object r = _wrapperOnceExec(params, reqData, usrTag, psrId);
         // 此段根据python的返回 ，回写 respData
         Response *resp;
         spdlog::debug("start cast python resp to c++ object, thread_id: {}, sid: {}", gettid(), sid);
@@ -334,7 +343,7 @@ int PyWrapper::wrapperOnceExec(const char *usrTag, std::map <std::string, std::s
 
 
 int PyWrapper::wrapperOnceExecAsync(const char *usrTag, std::map <std::string, std::string> params, DataListCls reqData,
-                                    std::string sid, wrapperCallback cb) {
+                                    std::string sid, wrapperCallback cb, unsigned int psrId) {
     try {
         if (cb != nullptr) {
             SetSidCallBack(cb, sid);
@@ -344,7 +353,7 @@ int PyWrapper::wrapperOnceExecAsync(const char *usrTag, std::map <std::string, s
         SetSidUsrTag(sid, usrTag);
         params["sid"] = sid;
         // 执行python exec 推理
-        py::object r = _wrapperOnceExecAsync(params, reqData, sid);
+        py::object r = _wrapperOnceExecAsync(params, reqData, sid, psrId);
         // 此段根据python的返回 ，回写 respData
         spdlog::info("start wrapperExecAsync cast python resp to c++ object, thread_id: {}, sid: {}", gettid(), sid);
         ret = r.cast<int>();
@@ -398,15 +407,15 @@ int PyWrapper::wrapperSetTraceFunc(CtrlType type, wrapperTraceLog mc) {
 
 std::string
 PyWrapper::wrapperCreate(const char *usrTag, std::map <std::string, std::string> params, wrapperCallback cb,
-                         int *errNum, std::string sid) {
+                         int *errNum, std::string sid, unsigned int psrId) {
     SessionCreateResponse *resp;
     SetSidCallBack(cb, sid);
     SetSidUsrTag(sid, usrTag);
 
     try {
         py::gil_scoped_acquire acquire;
         // 此段根据python的返回 ，回写 respData
-        py::object r = _wrapperCreate(params, sid);
+        py::object r = _wrapperCreate(params, sid, psrId);
         resp = r.cast<SessionCreateResponse *>();
         *errNum = resp->errCode;
         if (*errNum != 0) {
@@ -525,6 +534,36 @@ int PyWrapper::wrapperExecFree(const char *usrTag) {
     return 0;
 }
 
+int PyWrapper::wrapperLoadRes(pDataList p, unsigned int resId) {
+    DataListCls perData;
+    if (dataNum > 0) {
+        for (int tmpIdx = 0; tmpIdx < dataNum; tmpIdx++) {
+            DataListNode item;
+            item.key = p->key;
+
+            // 直接拷贝
+            size_t len = static_cast<size_t>(p->len);
+            item.data = py::bytes((char *) (p->data), len);
+
+            item.len = p->len;
+            char t = static_cast<int>(p->type);
+            item.type = p->type;
+            item.status = p->status;
+            spdlog::debug("reqDatatype :{}，sid:{}", p->type, sid);
+            perData.list.push_back(item);
+            p = p->next;
+        }
+    }
+    py::gil_scoped_acquire acquire;
+    // 执行python exec 推理
+    py::object r = _wrapperLoadRes(perData, resId);
+    return  0;
+}
+
+int PyWrapper::wrapperUnloadRes(unsigned int resId) {
+    return 0;
+}
+
 int PyWrapper::wrapperTest() {
     py::gil_scoped_acquire acquire;
     std::vector <py::dict> req;

pyWrapper.h

@@ -123,16 +123,16 @@ class PyWrapper {
 
     int wrapperOnceExec(const char *usrTag, std::map <std::string, std::string> params, DataListCls reqData,
                         pDataList *respData,
-                        std::string sid, wrapperCallback cb);
+                        std::string sid, wrapperCallback cb, unsigned int psrId);
 
     int wrapperOnceExecAsync(const char *usrTag, std::map <std::string, std::string> params, DataListCls reqData,
-                             std::string sid, wrapperCallback cb);
+                             std::string sid, wrapperCallback cb, unsigned int psrId);
 
     int wrapperFini();
 
     std::string
     wrapperCreate(const char *usrTag, std::map <std::string, std::string> params, wrapperCallback cb, int *errNum,
-                  std::string sid);
+                  std::string sid, unsigned int psrId);
 
     int wrapperSetMetricFunc(CtrlType type, wrapperMeterCustom mc);
 
@@ -148,6 +148,10 @@ class PyWrapper {
 
     int wrapperTest();
 
+    int wrapperLoadRes(pDataList perData, unsigned int resId);
+
+    int wrapperUnloadRes(unsigned int resId);
+
     void setCallBack(wrapperCallback cb);
 
     wrapperMeterCustom metric_cb;
@@ -164,6 +168,8 @@ class PyWrapper {
     py::object _wrapperCreate;
     py::object _wrapperWrite;
     py::object _wrapperRead;
+    py::object _wrapperLoadRes;
+    py::object _wrapperUnloadRes;
     py::object _wrapperTest;
 
     wrapperCallback cb_;

wrapper.cpp

@@ -136,11 +136,13 @@ const char *WrapperAPI wrapperVersion() {
 }
 
 int WrapperAPI wrapperLoadRes(pDataList perData, unsigned int resId) {
-    return 0;
+    int ret = pyWrapper->wrapperLoadRes(perData, resId);
+    return ret;
 }
 
 int WrapperAPI wrapperUnloadRes(unsigned int resId) {
-    return 0;
+    int ret = pyWrapper->wrapperUnloadRes(resId);
+    return ret;
 }
 
 const void *
@@ -171,7 +173,13 @@ WrapperAPI wrapperCreate(const char *usrTag, pParamList params, wrapperCallback
         spdlog::debug("wrapper create param, key:{},value:{},sid:{}", p->key, p->value, sid);
     }
 
-    std::string handle = pyWrapper->wrapperCreate(usrTag, pyParams, cb, errNum, sid);
+    unsigned int psrId = 0;
+    if (psrCnt > 0) {
+        // 对于python加载器只运行有1个psr资源
+        psrId = psrIds[0];
+    }
+
+    std::string handle = pyWrapper->wrapperCreate(usrTag, pyParams, cb, errNum, sid, psrId);
     char *handlePtr = strdup(handle.c_str());
     if (*errNum != 0) {
         spdlog::debug("wrapper exec Error, errNum:{}, sid:{}", *errNum, sid);
@@ -199,7 +207,6 @@ int WrapperAPI wrapperWrite(const void *handle, pDataList reqData) {
         for (int tmpIdx = 0; tmpIdx < dataNum; tmpIdx++) {
             DataListNode item;
             item.key = p->key;
-
             // 直接拷贝
             size_t len = static_cast<size_t>(p->len);
             item.data = py::bytes((char *) (p->data), len);
@@ -311,9 +318,13 @@ wrapperExec(const char *usrTag, pParamList params, pDataList reqData, pDataList
             p = p->next;
         }
     }
-
+    unsigned int psrId = 0;
+    if (psrCnt > 0) {
+        // 对于python加载器只运行有1个psr资源
+        psrId = psrIds[0];
+    }
     // 构造响应数据
-    ret = pyWrapper->wrapperOnceExec(usrTag, pyParams, req, respData, sid, nullptr);
+    ret = pyWrapper->wrapperOnceExec(usrTag, pyParams, req, respData, sid, nullptr, psrId);
     if (ret != 0) {
         spdlog::error("wrapper exec error!");
         return ret;
@@ -430,8 +441,13 @@ wrapperExecAsync(const char *usrTag, pParamList params, pDataList reqData, wrapp
         }
     }
 
+    unsigned int psrId = 0;
+    if (psrCnt > 0) {
+        // 对于python加载器只运行有1个psr资源
+        psrId = psrIds[0];
+    }
     // 构造响应数据
-    ret = pyWrapper->wrapperOnceExecAsync(usrTag, pyParams, req, sid, callback);
+    ret = pyWrapper->wrapperOnceExecAsync(usrTag, pyParams, req, sid, callback, psrId);
     if (ret != 0) {
         spdlog::get("stderr_console")->error("wrapper exec async error!");
         return ret;

wrapper.py

@@ -105,7 +105,7 @@ def wrapperInit(cls, config: {}) -> int:
         ret:错误码。无错误码时返回0
     '''
 
-    def wrapperOnceExec(cls, params: {}, reqData: DataListCls) -> Response:
+    def wrapperOnceExec(cls, params: {}, reqData: DataListCls, usrTag: str = "", psrID: int = 0) -> Response:
         log.info("got reqdata , %s" % reqData.list)
         #        print(type(reqData.list[0].data))
         #        print(type(reqData.list[0].data))
@@ -155,12 +155,18 @@ def wrapperError(cls, ret: int) -> str:
             return "user error defined here"
         return ""
 
-    def wrapperCreate(cls, params: {}, errNum: int, sid: str) -> str:
+    def wrapperCreate(cls, params: {}, errNum: int, sid: str, persId: int = 0) -> str:
         errNum = 5
         print(params)
         handle = "ccch"
         return handle
 
+    def wrapperLoadRes(self, reqData: DataListCls, resId: int) -> int:
+        return 0
+
+    def wrapperUnloadRes(self, resId: int) -> int:
+        return 0
+
     def wrapperTestFunc(cls, data: [], respData: []):
         r = Response()
         l = ResponseData()