diff --git a/inc/external/acl/acl_mdl.h b/inc/external/acl/acl_mdl.h
index ed2a96df3545bc0ecbc69cf018492fc7cbacbd4b..ea0886c6427dd0a3a6086afb717d51e0f886be4d 100755
--- a/inc/external/acl/acl_mdl.h
+++ b/inc/external/acl/acl_mdl.h
@@ -1480,6 +1480,21 @@ ACL_FUNC_VISIBILITY aclError aclmdlDestroyConfigHandle(aclmdlConfigHandle *handl
 ACL_FUNC_VISIBILITY aclError aclmdlSetConfigOpt(aclmdlConfigHandle *handle, aclmdlConfigAttr attr,
     const void *attrValue, size_t valueSize);
 
+/**
+ * @ingroup AscendCL
+ * @brief set config for model load
+ *
+ * @param handle [IN]    pointer to model config handle
+ * @param fileName [IN]  external weight file name
+ * @param deviceAddr [IN]  a pointer to device memory. User should copy external weight data here
+ * @param memSize [IN]  memory size of deviceAddr, need 32-byte alignment
+ *
+ * @retval ACL_SUCCESS The function is successfully executed.
+ * @retval OtherValues Failure
+ */
+ACL_FUNC_VISIBILITY aclError aclmdlSetExternalWeightAddress(aclmdlConfigHandle *handle, const char *fileName,
+                                                            void *deviceAddr, size_t memSize);
+
 /**
  * @ingroup AscendCL
  * @brief set config for model execute
diff --git a/model/model.cpp b/model/model.cpp
index 8d8722b32a5e23428bf0c2693e83101ac8d413f7..1afa286be97eb621a7a7a88a10cf6a311270600c 100755
--- a/model/model.cpp
+++ b/model/model.cpp
@@ -30,7 +30,7 @@
 #include "error_codes_inner.h"
 #include "toolchain/profiling_manager.h"
 #include "toolchain/resource_statistics.h"
-#include "framework/common/ge_types.h"
+#include "common/ge_common/ge_types.h"
 #include "framework/runtime/model_v2_executor.h"
 #include "framework/runtime/gert_api.h"
 #include "framework/runtime/subscriber/global_profiler.h"
@@ -68,6 +68,30 @@ enum class TensorType : std::uint8_t {
     INPUT_TENSOR_TYPE = 0,
     OUTPUT_TENSOR_TYPE
 };
+
+aclError aclmdlCheckQueueParam(const uint32_t *const inputQ, const size_t inputQNum, const uint32_t *const outputQ,
+                               const size_t outputQNum) {
+    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(inputQ);
+    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(outputQ);
+    if ((inputQNum == 0U) || (outputQNum == 0U)) {
+        ACL_LOG_INNER_ERROR("[Check][QNum]inputQNum[%zu] or outputQNum[%zu] is invalid, can't be zero",
+                            inputQNum, outputQNum);
+        return ACL_ERROR_INVALID_PARAM;
+    }
+    return ACL_SUCCESS;
+}
+
+ge::ModelLoadArg ConstructGeModelLoadArg(void *devPtr, size_t memSize, void *weightPtr, size_t weightSize,
+    gert::RtSession *rtSession = nullptr, const std::vector<ge::FileConstantMem> &fileConstantMems = {}) {
+    ge::ModelLoadArg loadArgs;
+    loadArgs.dev_ptr = devPtr;
+    loadArgs.mem_size = memSize;
+    loadArgs.weight_ptr = weightPtr;
+    loadArgs.weight_size = weightSize;
+    loadArgs.rt_session = rtSession;
+    loadArgs.file_constant_mems = fileConstantMems;
+    return loadArgs;
+}
 }
 
 aclmdlDesc *aclmdlCreateDesc()
@@ -256,11 +280,11 @@ static aclError RuntimeV2GetModelOutputShapeInfo(aclmdlDesc *const modelDesc, co
     return GetModelOutputShapeInfoHelp(modelDesc, geDynamicOutputShape);
 }
 
-static aclError ModelLoadFromFileWithMem(const char_t *const modelPath, uint32_t *const modelId, void *const workPtr,
-    const size_t workSize, void *const weightPtr, const size_t weightSize, const int32_t priority)
+static aclError ModelLoadFromFileWithMem(const char_t *const modelPath, uint32_t *const modelId,
+    const ge::ModelLoadArg &loadArgs, const int32_t priority)
 {
     ACL_LOG_INFO("start to execute ModelLoadFromFileWithMem, modelPath[%s], "
-        "workSize[%zu], weightSize[%zu], priority[%d]", modelPath, workSize, weightSize, priority);
+        "workSize[%zu], weightSize[%zu], priority[%d]", modelPath, loadArgs.mem_size, loadArgs.weight_size, priority);
 
     ge::GeExecutor executor;
     uint32_t id = 0U;
@@ -268,7 +292,7 @@ static aclError ModelLoadFromFileWithMem(const char_t *const modelPath, uint32_t
     const std::string path(modelPath);
     data.om_path = path;
     ACL_LOG_INFO("call ge interface executor.LoadDataFromFile, workSize[%zu], weightSize[%zu]",
-        workSize, weightSize);
+                 loadArgs.mem_size, loadArgs.weight_size);
     ge::Status ret = executor.LoadDataFromFile(path, data);
     if (ret != ge::SUCCESS) {
         ACL_LOG_CALL_ERROR("[Model][FromFile]load model from file[%s] failed, ge result[%u]", modelPath, ret);
@@ -276,9 +300,9 @@ static aclError ModelLoadFromFileWithMem(const char_t *const modelPath, uint32_t
         return ACL_GET_ERRCODE_GE(static_cast<int32_t>(ret));
     }
     data.priority = priority;
-    ACL_LOG_INFO("call ge interface executor.LoadModelFromData, workSize[%zu], weightSize[%zu]",
-        workSize, weightSize);
-    ret = executor.LoadModelFromData(id, data, workPtr, workSize, weightPtr, weightSize);
+    ACL_LOG_INFO("call ge interface executor.LoadModelFromDataWithArgs, workSize[%zu], weightSize[%zu]",
+                 loadArgs.mem_size, loadArgs.weight_size);
+    ret = executor.LoadModelFromDataWithArgs(id, data, loadArgs);
     if (ret != ge::SUCCESS) {
         ACL_LOG_CALL_ERROR("[Model][FromData]load model from data failed, ge result[%u]", ret);
         ACL_DELETE_ARRAY(data.model_data);
@@ -288,21 +312,22 @@ static aclError ModelLoadFromFileWithMem(const char_t *const modelPath, uint32_t
     *modelId = id;
     ACL_DELETE_ARRAY(data.model_data);
     ACL_LOG_INFO("successfully execute ModelLoadFromFileWithMem, workSize[%zu], weightSize[%zu], modelId[%u]",
-        workSize, weightSize, *modelId);
+                 loadArgs.mem_size, loadArgs.weight_size, *modelId);
     return ACL_SUCCESS;
 }
 
 static aclError RuntimeV2ModelLoadCommon(ge::ModelData &modelData, uint32_t *const modelId,
-    const void *const weightPtr, const size_t weightSize, const std::shared_ptr<gert::RtSession> &rtSessionExternal)
+    const void *const weightPtr, const size_t weightSize, std::vector<ge::FileConstantMem> file_constant_mems,
+    const std::shared_ptr<gert::RtSession> &rtSessionExternal)
 {
     ACL_LOG_INFO("call ge interface gert::LoadExecutorFromModelData, weightSize[%zu]", weightSize);
     ge::graphStatus ret = ge::GRAPH_SUCCESS;
     std::unique_ptr<gert::ModelV2Executor> executor;
-    if (rtSessionExternal == nullptr) { // old process, tmp solution
-        executor = gert::LoadExecutorFromModelData(modelData, ret);
-    } else { // new process, delete old process after ge api ready
-        executor = gert::LoadExecutorFromModelDataWithRtSession(modelData, rtSessionExternal.get(), ret);
-    }
+    gert::LoadExecutorArgs args = {
+        .rt_session = rtSessionExternal.get(),
+        .file_constant_mems = std::move(file_constant_mems)
+    };
+    executor = gert::LoadExecutorFromModelData(modelData, args, ret);
     if (ret != ge::GRAPH_SUCCESS) {
         ACL_LOG_CALL_ERROR("[Model][FromData]call gert::LoadExecutorFromModelDataWithMem load model from data failed, "
                            "ge result[%u]", ret);
@@ -342,6 +367,7 @@ static aclError RuntimeV2ModelLoadCommon(ge::ModelData &modelData, uint32_t *con
 static aclError RuntimeV2ModelLoadFromFileWithMem(const char_t *const modelPath, uint32_t *const modelId,
                                                   void *const weightPtr, const size_t weightSize,
                                                   const int32_t priority,
+                                                  std::vector<ge::FileConstantMem> file_constant_mems = {},
                                                   const std::shared_ptr<gert::RtSession> &rtSessionExternal = nullptr)
 {
     ACL_LOG_INFO("start to execute RuntimeV2ModelLoadFromFileWithMem, priority[%d], weightSize[%zu]",
@@ -362,20 +388,19 @@ static aclError RuntimeV2ModelLoadFromFileWithMem(const char_t *const modelPath,
     // 2. config model data
     modelData.priority = priority;
     // 3. get rt2.0 executor
-    ACL_REQUIRES_OK(RuntimeV2ModelLoadCommon(modelData, modelId, weightPtr, weightSize, rtSessionExternal));
+    ACL_REQUIRES_OK(RuntimeV2ModelLoadCommon(modelData, modelId, weightPtr, weightSize, std::move(file_constant_mems),
+                                             rtSessionExternal));
     ACL_LOG_INFO("successfully execute RuntimeV2ModelLoadFromFileWithMem, modelSize[%lu], modelId[%u], weightSize[%zu]",
                  modelData.model_len, *modelId, weightSize);
     return ACL_SUCCESS;
 }
 
 static aclError ModelLoadFromMemWithMem(const void *const model, const size_t modelSize, const std::string &modelPath,
-                                        uint32_t *const modelId,void *const workPtr, const size_t workSize,
-                                        void *const weightPtr, const size_t weightSize, const char_t *const weightPath,
-                                        const int32_t priority,
-                                        const std::shared_ptr<gert::RtSession> &rtSessionExternal = nullptr)
+                                        uint32_t *const modelId, const ge::ModelLoadArg &loadArgs,
+                                        const char_t *const weightPath, const int32_t priority)
 {
     ACL_LOG_INFO("start to execute ModelLoadFromMemWithMem, workSize[%zu], weightSize[%zu], priority[%d]",
-        workSize, weightSize, priority);
+                 loadArgs.mem_size, loadArgs.weight_size, priority);
     if (modelSize == 0U) {
         ACL_LOG_INNER_ERROR("[Check][ModelSize]modelSize[%zu] is invalid, should not be zero", modelSize);
         return ACL_ERROR_INVALID_PARAM;
@@ -392,20 +417,9 @@ static aclError ModelLoadFromMemWithMem(const void *const model, const size_t mo
         modelData.weight_path = std::string(weightPath);
         ACL_LOG_INFO("Load weight path is [%s]", modelData.weight_path.c_str());
     }
-    ACL_LOG_INFO("call ge interface executor.LoadModelFromData, modelSize[%zu], workSize[%zu], weightSize[%zu]",
-        modelSize, workSize, weightSize);
-    ge::Status ret = ge::SUCCESS;
-    if (rtSessionExternal == nullptr) {
-        ret = geExecutor.LoadModelFromData(id, modelData, workPtr, workSize, weightPtr, weightSize);
-    } else {
-        ge::ModelLoadArg loadArgs{};
-        loadArgs.dev_ptr = workPtr;
-        loadArgs.mem_size = workSize;
-        loadArgs.weight_ptr = weightPtr;
-        loadArgs.weight_size = weightSize;
-        loadArgs.rt_session = rtSessionExternal.get();
-        ret = geExecutor.LoadModelFromDataWithArgs(id, modelData, loadArgs);
-    }
+    ACL_LOG_INFO("call ge interface executor.LoadModelFromDataWithArgs, modelSize[%zu], workSize[%zu], weightSize[%zu]",
+        modelSize, loadArgs.mem_size, loadArgs.weight_size);
+    const auto ret = geExecutor.LoadModelFromDataWithArgs(id, modelData, loadArgs);
     if (ret != ge::SUCCESS) {
         ACL_LOG_CALL_ERROR("[Model][FromData]load model from data failed, ge result[%u]", ret);
         return ACL_GET_ERRCODE_GE(static_cast<int32_t>(ret));
@@ -413,7 +427,7 @@ static aclError ModelLoadFromMemWithMem(const void *const model, const size_t mo
 
     *modelId = id;
     ACL_LOG_INFO("successfully execute ModelLoadFromMemWithMem, modelSize[%zu], workSize[%zu], "
-        "weightSize[%zu], modelId[%u]", modelSize, workSize, weightSize, *modelId);
+        "weightSize[%zu], modelId[%u]", modelSize, loadArgs.mem_size, loadArgs.weight_size, *modelId);
     return ACL_SUCCESS;
 }
 
@@ -492,6 +506,7 @@ static aclError RuntimeV2ModelLoadFromMemWithMem(const void *const model, const
                                                  uint32_t *const modelId, void *const weightPtr,
                                                  const size_t weightSize, const char_t *const weightPath,
                                                  const int32_t priority,
+                                                 std::vector<ge::FileConstantMem> file_constant_mems = {},
                                                  const std::shared_ptr<gert::RtSession> &rtSessionExternal = nullptr)
 {
     ACL_LOG_INFO("start to execute RuntimeV2ModelLoadFromMemWithMem, modelSize[%zu], priority[%d], weightSize[%zu]",
@@ -510,28 +525,20 @@ static aclError RuntimeV2ModelLoadFromMemWithMem(const void *const model, const
     }
 
     // 2. get executorV2
-    ACL_REQUIRES_OK(RuntimeV2ModelLoadCommon(modelData, modelId, weightPtr, weightSize, rtSessionExternal));
+    ACL_REQUIRES_OK(RuntimeV2ModelLoadCommon(modelData, modelId, weightPtr, weightSize, std::move(file_constant_mems),
+                                             rtSessionExternal));
     ACL_LOG_INFO("successfully execute RuntimeV2ModelLoadFromMemWithMem, modelSize[%zu], modelId[%u], weightSize[%zu]",
                  modelSize, *modelId, weightSize);
     return ACL_SUCCESS;
 }
 
 static aclError ModelLoadFromFileWithQ(const char_t *const modelPath, uint32_t *const modelId,
-    const uint32_t *const inputQ, const size_t inputQNum, const uint32_t *const outputQ,
-    const size_t outputQNum, const int32_t priority)
+    const ge::ModelQueueArg &args, const int32_t priority)
 {
     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelPath);
     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelId);
-    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(inputQ);
-    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(outputQ);
     ACL_LOG_INFO("start to execute ModelLoadFromFileWithQ, modelPath[%s], inputQNum[%zu], "
-        "outputQNum[%zu], priority[%d]", modelPath, inputQNum, outputQNum, priority);
-
-    if ((inputQNum == 0U) || (outputQNum == 0U)) {
-        ACL_LOG_INNER_ERROR("[Check][QNum]inputQNum[%zu] or outputQNum[%zu] is invalid, can't be zero",
-            inputQNum, outputQNum);
-        return ACL_ERROR_INVALID_PARAM;
-    }
+        "outputQNum[%zu], priority[%d]", modelPath, args.input_queue_ids.size(), args.output_queue_ids.size(), priority);
 
     ge::GeExecutor geExecutor;
     uint32_t id = 0U;
@@ -545,11 +552,8 @@ static aclError ModelLoadFromFileWithQ(const char_t *const modelPath, uint32_t *
         return ACL_GET_ERRCODE_GE(static_cast<int32_t>(ret));
     }
     modelData.priority = priority;
-    const std::vector<uint32_t> inputQVec(inputQ, inputQ + inputQNum);
-    const std::vector<uint32_t> outputQVec(outputQ, outputQ + outputQNum);
-
     ACL_LOG_INFO("call ge interface executor.LoadModelWithQ");
-    ret = geExecutor.LoadModelWithQ(id, modelData, inputQVec, outputQVec);
+    ret = geExecutor.LoadModelWithQ(id, modelData, args);
     if (ret != ge::SUCCESS) {
         ACL_LOG_CALL_ERROR("[Load][WithQ]execute LoadModelWithQ failed, ge result[%u]", ret);
         ACL_DELETE_ARRAY(modelData.model_data);
@@ -558,26 +562,22 @@ static aclError ModelLoadFromFileWithQ(const char_t *const modelPath, uint32_t *
 
     *modelId = id;
     ACL_DELETE_ARRAY(modelData.model_data);
-
     ACL_LOG_INFO("successfully execute ModelLoadFromFileWithQ, modelPath[%s], inputQNum[%zu], outputQNum[%zu], "
-        "modelId[%u]", modelPath, inputQNum, outputQNum, *modelId);
+        "modelId[%u]", modelPath, args.input_queue_ids.size(), args.output_queue_ids.size(), *modelId);
     return ACL_SUCCESS;
 }
 
 static aclError ModelLoadFromMemWithQ(const void *const model, const size_t modelSize, uint32_t *const modelId,
-    const uint32_t *const inputQ, const size_t inputQNum, const uint32_t *const outputQ,
-    const size_t outputQNum, const int32_t priority)
+    const ge::ModelQueueArg &args, const int32_t priority)
 {
     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(model);
     ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelId);
-    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(inputQ);
-    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(outputQ);
     ACL_LOG_INFO("start to execute ModelLoadFromMemWithQ, modelSize[%zu], inputQNum[%zu], outputQNum[%zu], "
-        "priority[%d]", modelSize, inputQNum, outputQNum, priority);
+        "priority[%d]", modelSize, args.input_queue_ids.size(), args.output_queue_ids.size(), priority);
 
-    if ((modelSize == 0U) || (inputQNum == 0U) || (outputQNum == 0U)) {
-        ACL_LOG_INNER_ERROR("[Check][Params]modelSize[%zu] or inputQNum[%zu] or outputQNum[%zu] is invalid, "
-            "can't be zero", modelSize, inputQNum, outputQNum);
+    if (modelSize == 0U) {
+        ACL_LOG_INNER_ERROR("[Check][Params]modelSize[%zu] is invalid, "
+            "can't be zero", modelSize);
         return ACL_ERROR_INVALID_PARAM;
     }
 
@@ -589,11 +589,8 @@ static aclError ModelLoadFromMemWithQ(const void *const model, const size_t mode
     data.model_len = static_cast<uint64_t>(modelSize);
     data.priority = priority;
 
-    const std::vector<uint32_t> inputQVec(inputQ, inputQ + inputQNum);
-    const std::vector<uint32_t> outputQVec(outputQ, outputQ + outputQNum);
-
     ACL_LOG_INFO("call ge interface executor.LoadModelWithQ, modelSize[%zu]", modelSize);
-    const ge::Status ret = executor.LoadModelWithQ(id, data, inputQVec, outputQVec);
+    const ge::Status ret = executor.LoadModelWithQ(id, data, args);
     if (ret != ge::SUCCESS) {
         ACL_LOG_CALL_ERROR("[Load][WithQ]load model with Q, ge result[%u], failed", ret);
         return ACL_GET_ERRCODE_GE(static_cast<int32_t>(ret));
@@ -601,7 +598,7 @@ static aclError ModelLoadFromMemWithQ(const void *const model, const size_t mode
 
     *modelId = id;
     ACL_LOG_INFO("successfully execute ModelLoadFromMemWithQ, modelSize[%zu], inputQNum[%zu], outputQNum[%zu], "
-        "modelId[%u]", modelSize, inputQNum, outputQNum, *modelId);
+        "modelId[%u]", modelSize, args.input_queue_ids.size(), args.output_queue_ids.size(), *modelId);
 
     return ACL_SUCCESS;
 }
@@ -1855,10 +1852,12 @@ static aclError BundleLoadFromMem(const void *model, size_t modelSize,
         aclError ret = ACL_SUCCESS;
         if (isSupportRT2) {
             ret = acl::RuntimeV2ModelLoadFromMemWithMem(currentModePtr, offsetSize.second, modelPath,
-                                                        &currentModelId, nullptr, 0U, nullptr, 0, rtSession);
+                                                        &currentModelId, nullptr, 0U, nullptr, 0, {}, rtSession);
         } else {
+            const auto loadArgs = ConstructGeModelLoadArg(nullptr, 0U, nullptr,
+                0U, rtSession.get(), {});
             ret = acl::ModelLoadFromMemWithMem(currentModePtr, offsetSize.second, modelPath,
-                                               &currentModelId, nullptr, 0U, nullptr, 0U, nullptr, 0, rtSession);
+                                               &currentModelId, loadArgs, nullptr, 0);
         }
         if (ret != ACL_SUCCESS) {
             for (const auto &ele : bundleInfos) {
@@ -1933,7 +1932,8 @@ aclError aclmdlLoadFromFile(const char *modelPath, uint32_t *modelId)
     if (isSupportRT2) {
         ret = acl::RuntimeV2ModelLoadFromFileWithMem(modelPath, modelId, nullptr, 0U, 0);
     } else {
-        ret = acl::ModelLoadFromFileWithMem(modelPath, modelId, nullptr, 0U, nullptr, 0U, 0);
+        ge::ModelLoadArg loadArgs{};
+        ret = acl::ModelLoadFromFileWithMem(modelPath, modelId, loadArgs, 0);
     }
     if (ret != ACL_SUCCESS) {
         ACL_LOG_ERROR("Load model from file failed!");
@@ -1960,7 +1960,8 @@ aclError aclmdlLoadFromFileWithMem(const char *modelPath, uint32_t *modelId,
     if (isSupportRT2) {
         ret = acl::RuntimeV2ModelLoadFromFileWithMem(modelPath, modelId, weightPtr, weightSize, 0);
     } else {
-        ret = acl::ModelLoadFromFileWithMem(modelPath, modelId, workPtr, workSize, weightPtr, weightSize, 0);
+        const auto loadArgs = ConstructGeModelLoadArg(workPtr, workSize, weightPtr, weightSize);
+        ret = acl::ModelLoadFromFileWithMem(modelPath, modelId, loadArgs, 0);
     }
     if (ret != ACL_SUCCESS) {
         return ret;
@@ -1985,7 +1986,8 @@ aclError aclmdlLoadFromMem(const void *model, size_t modelSize, uint32_t *modelI
     if (isSupportRT2) {
         ret = acl::RuntimeV2ModelLoadFromMemWithMem(model, modelSize, "", modelId, nullptr, 0U, nullptr, 0);
     } else {
-        ret = acl::ModelLoadFromMemWithMem(model, modelSize, "", modelId, nullptr, 0U, nullptr, 0U, nullptr, 0);
+        ge::ModelLoadArg loadArgs{};
+        ret = acl::ModelLoadFromMemWithMem(model, modelSize, "", modelId, loadArgs, nullptr, 0);
     }
     if (ret != ACL_SUCCESS) {
         return ret;
@@ -2040,8 +2042,8 @@ aclError aclmdlLoadFromMemWithMem(const void *model, size_t modelSize,
         ret = acl::RuntimeV2ModelLoadFromMemWithMem(model, modelSize, "", modelId,
                                                     weightPtr, weightSize, nullptr, 0);
     } else {
-        ret = acl::ModelLoadFromMemWithMem(model, modelSize, "", modelId, workPtr,
-                                           workSize, weightPtr, weightSize, nullptr, 0);
+        const auto loadArgs = ConstructGeModelLoadArg(workPtr, workSize, weightPtr, weightSize);
+        ret = acl::ModelLoadFromMemWithMem(model, modelSize, "", modelId, loadArgs, nullptr, 0);
     }
     if (ret != ACL_SUCCESS) {
         return ret;
@@ -2058,8 +2060,15 @@ aclError aclmdlLoadFromFileWithQ(const char *modelPath, uint32_t *modelId, const
     ACL_PROFILING_REG(acl::AclProfType::AclmdlLoadFromFileWithQ);
     ACL_STAGES_REG(acl::ACL_STAGE_LOAD, acl::ACL_STAGE_DEFAULT);
     ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_LOAD_UNLOAD_MODEL);
+    if (aclmdlCheckQueueParam(inputQ, inputQNum, outputQ, outputQNum) != ACL_SUCCESS) {
+        return ACL_ERROR_INVALID_PARAM;
+    }
     ACL_LOG_INFO("start to execute aclmdlLoadFromFileWithQ, inputQNum[%zu], outputQNum[%zu]", inputQNum, outputQNum);
-    const aclError ret = acl::ModelLoadFromFileWithQ(modelPath, modelId, inputQ, inputQNum, outputQ, outputQNum, 0);
+    std::vector<uint32_t> inputQVec(inputQ, inputQ + inputQNum);
+    std::vector<uint32_t> outputQVec(outputQ, outputQ + outputQNum);
+    ge::ModelQueueArg args{.input_queue_ids = std::move(inputQVec), .output_queue_ids = std::move(outputQVec),
+                        .file_constant_mems = {}};
+    const aclError ret = acl::ModelLoadFromFileWithQ(modelPath, modelId, args, 0);
     if (ret != ACL_SUCCESS) {
         return ret;
     }
@@ -2075,10 +2084,16 @@ aclError aclmdlLoadFromMemWithQ(const void *model, size_t modelSize, uint32_t *m
     ACL_PROFILING_REG(acl::AclProfType::AclmdlLoadFromMemWithQ);
     ACL_STAGES_REG(acl::ACL_STAGE_LOAD, acl::ACL_STAGE_DEFAULT);
     ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_LOAD_UNLOAD_MODEL);
+    if (aclmdlCheckQueueParam(inputQ, inputQNum, outputQ, outputQNum) != ACL_SUCCESS) {
+        return ACL_ERROR_INVALID_PARAM;
+    }
     ACL_LOG_INFO("start to execute aclmdlLoadFromMemWithQ, modelSize[%zu], inputQNum[%zu], outputQNum[%zu]",
         modelSize, inputQNum, outputQNum);
-    const aclError ret = acl::ModelLoadFromMemWithQ(model, modelSize, modelId,
-        inputQ, inputQNum, outputQ, outputQNum, 0);
+    std::vector<uint32_t> inputQVec(inputQ, inputQ + inputQNum);
+    std::vector<uint32_t> outputQVec(outputQ, outputQ + outputQNum);
+    ge::ModelQueueArg args{.input_queue_ids = std::move(inputQVec), .output_queue_ids = std::move(outputQVec),
+                        .file_constant_mems = {}};
+    const aclError ret = acl::ModelLoadFromMemWithQ(model, modelSize, modelId, args, 0);
     if (ret != ACL_SUCCESS) {
         return ret;
     }
@@ -2891,7 +2906,11 @@ aclError aclmdlLoadWithConfig(const aclmdlConfigHandle *handle, uint32_t *modelI
         return ACL_ERROR_INVALID_PARAM;
     }
     acl::UpdateGraphOptions(OPTION_EXEC_REUSE_ZERO_COPY_MEMORY, std::to_string(handle->reuseZeroCopy));
-
+    auto &file_constant_mems = handle->fileConstantMem;
+    for (const auto &file_constant_mem : file_constant_mems) {
+        ACL_LOG_INFO("file constant name[%s], device memory address[%p], device memory size[%zu]",
+                     file_constant_mem.file_name.c_str(), file_constant_mem.device_mem, file_constant_mem.mem_size);
+    }
     bool isSupportRT2 = false;
     switch (static_cast<int32_t>(handle->mdlLoadType)) {
         case ACL_MDL_LOAD_FROM_FILE:
@@ -2899,21 +2918,23 @@ aclError aclmdlLoadWithConfig(const aclmdlConfigHandle *handle, uint32_t *modelI
             ACL_REQUIRES_OK(acl::IsSupportRuntimeV2WithModelPath(handle->loadPath.c_str(), isSupportRT2));
             if (isSupportRT2) {
                 return acl::RuntimeV2ModelLoadFromFileWithMem(handle->loadPath.c_str(), modelId, nullptr, 0U,
-                                                              handle->priority);
+                                                              handle->priority, file_constant_mems);
             }
-            return acl::ModelLoadFromFileWithMem(handle->loadPath.c_str(), modelId,
-                                                 nullptr, 0U, nullptr, 0U, handle->priority);
+            ge::ModelLoadArg loadArgs{};
+            loadArgs.file_constant_mems = file_constant_mems;
+            return acl::ModelLoadFromFileWithMem(handle->loadPath.c_str(), modelId, loadArgs, handle->priority);
         }
         case ACL_MDL_LOAD_FROM_FILE_WITH_MEM:
         {
             ACL_REQUIRES_OK(acl::IsSupportRuntimeV2WithModelPath(handle->loadPath.c_str(), isSupportRT2));
             if (isSupportRT2) {
                 return acl::RuntimeV2ModelLoadFromFileWithMem(handle->loadPath.c_str(), modelId, handle->weightPtr,
-                                                              handle->weightSize, handle->priority);
+                                                              handle->weightSize, handle->priority,
+                                                              file_constant_mems);
             }
-            return acl::ModelLoadFromFileWithMem(handle->loadPath.c_str(), modelId, handle->workPtr,
-                                                 handle->workSize, handle->weightPtr, handle->weightSize,
-                                                 handle->priority);
+            const auto loadArgs = ConstructGeModelLoadArg(handle->workPtr, handle->workSize, handle->weightPtr,
+                handle->weightSize, nullptr, file_constant_mems);
+            return acl::ModelLoadFromFileWithMem(handle->loadPath.c_str(), modelId, loadArgs, handle->priority);
         }
         case ACL_MDL_LOAD_FROM_MEM:
         {
@@ -2921,9 +2942,12 @@ aclError aclmdlLoadWithConfig(const aclmdlConfigHandle *handle, uint32_t *modelI
             ACL_REQUIRES_OK(acl::IsSupportRuntimeV2WithModelData(handle->mdlAddr, handle->mdlSize, isSupportRT2));
             if (isSupportRT2) {
                 return acl::RuntimeV2ModelLoadFromMemWithMem(handle->mdlAddr, handle->mdlSize, "", modelId, nullptr, 0U,
-                                                             handle->weightPath.c_str(), handle->priority);
+                                                             handle->weightPath.c_str(), handle->priority,
+                                                             file_constant_mems);
             }
-            return acl::ModelLoadFromMemWithMem(handle->mdlAddr, handle->mdlSize, "", modelId, nullptr, 0U, nullptr, 0U,
+            ge::ModelLoadArg loadArgs{};
+            loadArgs.file_constant_mems = file_constant_mems;
+            return acl::ModelLoadFromMemWithMem(handle->mdlAddr, handle->mdlSize, "", modelId, loadArgs,
                                                 handle->weightPath.c_str(), handle->priority);
         }
         case ACL_MDL_LOAD_FROM_MEM_WITH_MEM:
@@ -2933,19 +2957,37 @@ aclError aclmdlLoadWithConfig(const aclmdlConfigHandle *handle, uint32_t *modelI
             if (isSupportRT2) {
                 return acl::RuntimeV2ModelLoadFromMemWithMem(handle->mdlAddr, handle->mdlSize, "", modelId,
                                                              handle->weightPtr, handle->weightSize,
-                                                             nullptr, handle->priority);
+                                                             nullptr, handle->priority, file_constant_mems);
             }
-            return acl::ModelLoadFromMemWithMem(handle->mdlAddr, handle->mdlSize, "", modelId, handle->workPtr,
-                                                handle->workSize, handle->weightPtr, handle->weightSize,
+            const auto loadArgs = ConstructGeModelLoadArg(handle->workPtr, handle->workSize, handle->weightPtr,
+                handle->weightSize, nullptr, file_constant_mems);
+            return acl::ModelLoadFromMemWithMem(handle->mdlAddr, handle->mdlSize, "", modelId, loadArgs,
                                                 nullptr, handle->priority);
         }
         case ACL_MDL_LOAD_FROM_FILE_WITH_Q:
-            return acl::ModelLoadFromFileWithQ(handle->loadPath.c_str(), modelId, handle->inputQ,
-                handle->inputQNum, handle->outputQ, handle->outputQNum, handle->priority);
+        {
+            if (aclmdlCheckQueueParam(handle->inputQ, handle->inputQNum, handle->outputQ, handle->outputQNum) !=
+                ACL_SUCCESS) {
+                return ACL_ERROR_INVALID_PARAM;
+            }
+            std::vector<uint32_t> inputQVec(handle->inputQ, handle->inputQ + handle->inputQNum);
+            std::vector<uint32_t> outputQVec(handle->outputQ, handle->outputQ + handle->outputQNum);
+            ge::ModelQueueArg args{.input_queue_ids = std::move(inputQVec), .output_queue_ids = std::move(outputQVec),
+                                .file_constant_mems = file_constant_mems};
+            return acl::ModelLoadFromFileWithQ(handle->loadPath.c_str(), modelId, args, handle->priority);
+        }
         case ACL_MDL_LOAD_FROM_MEM_WITH_Q:
-            return acl::ModelLoadFromMemWithQ(handle->mdlAddr, handle->mdlSize, modelId,
-                handle->inputQ, handle->inputQNum,
-                handle->outputQ, handle->outputQNum, handle->priority);
+        {
+            if (aclmdlCheckQueueParam(handle->inputQ, handle->inputQNum, handle->outputQ, handle->outputQNum) !=
+                ACL_SUCCESS) {
+                return ACL_ERROR_INVALID_PARAM;
+            }
+            std::vector<uint32_t> inputQVec(handle->inputQ, handle->inputQ + handle->inputQNum);
+            std::vector<uint32_t> outputQVec(handle->outputQ, handle->outputQ + handle->outputQNum);
+            ge::ModelQueueArg que_args{.input_queue_ids = std::move(inputQVec), .output_queue_ids = std::move(outputQVec),
+                    .file_constant_mems = file_constant_mems};
+            return acl::ModelLoadFromMemWithQ(handle->mdlAddr, handle->mdlSize, modelId, que_args, handle->priority);
+        }
         default:
             ACL_LOG_INNER_ERROR("[Load][Model]model load type[%zu] is invalid, it should be in [%d, %d]",
                 handle->mdlLoadType, ACL_MDL_LOAD_FROM_FILE, ACL_MDL_LOAD_FROM_MEM_WITH_Q);
diff --git a/model/model_config.cpp b/model/model_config.cpp
index 38e7bae8a676fd16543a3df4bd371fcc854e4d4a..5b0533a3c007b7633b666b3e96dd6207ffefbd6e 100755
--- a/model/model_config.cpp
+++ b/model/model_config.cpp
@@ -580,6 +580,23 @@ aclError aclmdlSetConfigOpt(aclmdlConfigHandle *handle, aclmdlConfigAttr attr,
     return ACL_SUCCESS;
 }
 
+aclError aclmdlSetExternalWeightAddress(aclmdlConfigHandle *handle, const char *fileName,
+    void *deviceAddr, size_t memSize) {
+    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
+    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(fileName);
+    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(deviceAddr);
+    if ((memSize == 0U) || (memSize % 32U != 0U)) {
+        ACL_LOG_ERROR("[Check][Params]memSize[%zu] must > 0 and 32-byte aligned.", memSize);
+        return ACL_ERROR_INVALID_PARAM;
+    }
+
+    ge::FileConstantMem fileConstnatMem{.file_name = fileName, .device_mem = deviceAddr, .mem_size = memSize};
+    handle->fileConstantMem.emplace_back(std::move(fileConstnatMem));
+    ACL_LOG_INFO("successfully to execute aclmdlSetExternalWeightAddress, fileName[%s], deviceAddr[%p], memSize[%zu]",
+                 fileName, deviceAddr, memSize);
+    return ACL_SUCCESS;
+}
+
 aclmdlConfigHandle *aclmdlCreateConfigHandle()
 {
     ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_MODEL_CONFIG);
diff --git a/model/model_desc_internal.h b/model/model_desc_internal.h
index 123ef494f90e60da6541aa4a99ca1107832b9184..996bc01a588b13e40b2180d856641578a809072d 100755
--- a/model/model_desc_internal.h
+++ b/model/model_desc_internal.h
@@ -17,6 +17,8 @@
 #include <set>
 #include "acl/acl_base.h"
 #include "common/dynamic_aipp.h"
+#include "mmpa/mmpa_api.h"
+#include "common/ge_common/ge_types.h"
 
 struct aclmdlTensorDesc {
     aclmdlTensorDesc() : name(""), size(0U), format(ACL_FORMAT_UNDEFINED), dataType(ACL_DT_UNDEFINED) {}
@@ -158,6 +160,7 @@ struct aclmdlConfigHandle {
     size_t reuseZeroCopy;
     std::string weightPath;
     std::set<aclmdlConfigAttr> attrState;
+    std::vector<ge::FileConstantMem> fileConstantMem;
 };
 
 struct aclmdlExecConfigHandle {
diff --git a/tests/depends/acl_stub.h b/tests/depends/acl_stub.h
index 3f560f2aca943a9e64cf3b4e19512eafdcbddef0..d4c38c8db71e1afc59df68d1c704c590b6f5082d 100755
--- a/tests/depends/acl_stub.h
+++ b/tests/depends/acl_stub.h
@@ -122,6 +122,8 @@ public:
     virtual ge::Status LoadDataFromFile(std::string const &path, ModelData &modelData);
     virtual ge::Status LoadModelWithQ(uint32_t &model_id, const ge::ModelData &ge_model_data,
                                       const std::vector<uint32_t> &input_queue_ids, const std::vector<uint32_t> &output_queue_ids);
+    virtual ge::Status LoadModelWithQ(uint32_t &model_id, const ge::ModelData &ge_model_data,
+                                      const ge::ModelQueueArg &queue_arg);
     virtual ge::Status UnloadModel(uint32_t modelId);
     virtual ge::Status GetMemAndWeightSize(const std::string &path, size_t &mem_size, size_t &weight_size);
     virtual ge::Status GetMemAndWeightSize(const void *model_data, size_t model_size, size_t &mem_size, size_t &weight_size);
@@ -633,7 +635,10 @@ public:
     MOCK_METHOD3(LoadModelFromDataWithArgs, ge::Status(uint32_t &model_id, const ModelData &model_data, const ModelLoadArg &load_arg));
     MOCK_METHOD2(LoadDataFromFile, ge::Status(std::string const &path, ModelData &modelData));
     MOCK_METHOD4(LoadModelWithQ, ge::Status(uint32_t &model_id, const ge::ModelData &ge_model_data,
-                                            const std::vector<uint32_t> &input_queue_ids, const std::vector<uint32_t> &output_queue_ids));
+                                            const std::vector<uint32_t> &input_queue_ids,
+                                            const std::vector<uint32_t> &output_queue_ids));
+    MOCK_METHOD3(LoadModelWithQ, ge::Status(uint32_t &model_id, const ge::ModelData &ge_model_data,
+                                            const ge::ModelQueueArg &queue_arg));
     MOCK_METHOD1(UnloadModel, ge::Status(uint32_t modelId));
     MOCK_METHOD3(GetMemAndWeightSize, ge::Status(const std::string &path, size_t &mem_size, size_t &weight_size));
     MOCK_METHOD4(GetMemAndWeightSize, ge::Status(const void *model_data, size_t model_size, size_t &mem_size, size_t &weight_size));
@@ -680,7 +685,11 @@ public:
     MOCK_METHOD2(CreateAndLoad, gert::ModelV2Executor *(rtStream_t stream, const gert::ModelExecuteArg &arg));
     MOCK_METHOD1(Erase, ge::graphStatus(rtStream_t stream));
     MOCK_METHOD2(LoadExecutorFromFile, std::unique_ptr<gert::ModelV2Executor>(const char *file_path, ge::graphStatus &error_code));
-    MOCK_METHOD2(LoadExecutorFromModelData, std::unique_ptr<gert::ModelV2Executor>(const ge::ModelData &model_data, ge::graphStatus &error_code));
+    MOCK_METHOD2(LoadExecutorFromModelData, std::unique_ptr<gert::ModelV2Executor>(const ge::ModelData &model_data,
+                                                                                   ge::graphStatus &error_code));
+    MOCK_METHOD3(LoadExecutorFromModelData, std::unique_ptr<gert::ModelV2Executor>(const ge::ModelData &model_data,
+                                                                                   const gert::LoadExecutorArgs &args,
+                                                                                   ge::graphStatus &error_code));
     MOCK_METHOD3(LoadExecutorFromModelDataWithRtSession, std::unique_ptr<gert::ModelV2Executor> (const ge::ModelData &model_data,
                                                                                   gert::RtSession *const rt_session,
                                                                                   ge::graphStatus &error_code));
diff --git a/tests/depends/ge/src/ge_stub.cpp b/tests/depends/ge/src/ge_stub.cpp
index 3e6c3d895a6977e03469255432e581cf7711632e..63cbbafad438ed6370a341e6daaba9f7bfec7cbf 100755
--- a/tests/depends/ge/src/ge_stub.cpp
+++ b/tests/depends/ge/src/ge_stub.cpp
@@ -334,6 +334,12 @@ Status aclStub::LoadModelWithQ(uint32_t &model_id, const ge::ModelData &ge_model
     return SUCCESS;
 }
 
+Status aclStub::LoadModelWithQ(uint32_t &model_id, const ge::ModelData &ge_model_data,
+                const ge::ModelQueueArg &queue_arg)
+{
+    return SUCCESS;
+}
+
 Status aclStub::UnloadModel(uint32_t modelId)
 {
     return SUCCESS;
@@ -951,6 +957,12 @@ std::map<string, AnyValue> g_geAttrMap;
         return MockFunctionTest::aclStubInstance().LoadModelWithQ(model_id, ge_model_data, input_queue_ids, output_queue_ids);
     }
 
+    Status GeExecutor::LoadModelWithQ(uint32_t &model_id, const ge::ModelData &ge_model_data,
+                   const ge::ModelQueueArg &queue_arg)
+    {
+        return MockFunctionTest::aclStubInstance().LoadModelWithQ(model_id, ge_model_data, queue_arg);
+    }
+
     Status GeExecutor::UnloadModel(uint32_t modelId)
     {
         return MockFunctionTest::aclStubInstance().UnloadModel(modelId);
@@ -2190,6 +2202,13 @@ namespace gert {
         return MockFunctionTest::aclStubInstance().LoadExecutorFromModelData(model_data, error_code);
     }
 
+    std::unique_ptr<ModelV2Executor> LoadExecutorFromModelData(const ge::ModelData &model_data,
+                                                               const LoadExecutorArgs &args,
+                                                               ge::graphStatus &error_code)
+    {
+        return MockFunctionTest::aclStubInstance().LoadExecutorFromModelData(model_data, args, error_code);
+    }
+
     std::unique_ptr<gert::ModelV2Executor> LoadExecutorFromModelDataWithRtSession(const ge::ModelData &model_data,
                                                                                   gert::RtSession *const rt_session,
                                                                                   ge::graphStatus &error_code)
diff --git a/tests/ut/acl/testcase/acl_model_unittest.cpp b/tests/ut/acl/testcase/acl_model_unittest.cpp
index f6c899194bad1e668d446db40ae8903edf4ce8e9..e6b9815d764b77dcc71371b05ee7720d7836eabf 100755
--- a/tests/ut/acl/testcase/acl_model_unittest.cpp
+++ b/tests/ut/acl/testcase/acl_model_unittest.cpp
@@ -16,7 +16,6 @@
 #include "acl_stub.h"
 #include "graph/ge_context.h"
 
-
 using namespace testing;
 using namespace std;
 using namespace acl;
@@ -249,17 +248,39 @@ ge::graphStatus GetShapeRange_Invoke(std::vector<std::pair<int64_t,int64_t>> &ra
 }
 
 std::unique_ptr<gert::ModelV2Executor>
-LoadExecutorFromModelDataReturnError(const ge::ModelData &model_data, ge::graphStatus &error_code)
+LoadExecutorFromModelDataReturnError(const ge::ModelData &model_data,  const gert::LoadExecutorArgs &args,
+                                     ge::graphStatus &error_code)
 {
     (void) model_data;
+    (void) args;
     error_code = ge::GRAPH_FAILED;
     return nullptr;
 }
 
 std::unique_ptr<gert::ModelV2Executor>
-LoadExecutorFromModelDataSuccess(const ge::ModelData &model_data, ge::graphStatus &error_code)
+LoadExecutorFromModelDataSuccess(const ge::ModelData &model_data, const gert::LoadExecutorArgs &args,
+                                 ge::graphStatus &error_code)
+{
+    (void) model_data;
+    (void) args;
+    auto executor = std::unique_ptr<gert::ModelV2Executor>(new (std::nothrow) gert::ModelV2Executor);
+    error_code = ge::GRAPH_SUCCESS;
+    return executor;
+}
+
+std::unique_ptr<gert::ModelV2Executor>
+LoadExecutorFromModelDataCheckFileConstantMemSuccess(const ge::ModelData &model_data,
+                                                     const gert::LoadExecutorArgs &args,
+                                                     ge::graphStatus &error_code)
 {
     (void) model_data;
+    if (args.file_constant_mems.size() != 2U) {
+        return nullptr;
+    }
+    if (args.file_constant_mems[0].file_name != "fileconstant1.bin" ||
+        args.file_constant_mems[1].file_name != "fileconstant2.bin") {
+        return nullptr;
+    }
     auto executor = std::unique_ptr<gert::ModelV2Executor>(new (std::nothrow) gert::ModelV2Executor);
     error_code = ge::GRAPH_SUCCESS;
     return executor;
@@ -581,12 +602,12 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromFile)
     ret = aclmdlLoadFromFile(modelPath, &modelId);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromData(_,_,_,_,_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromDataWithArgs(_,_,_))
         .WillOnce(Return((ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED)));
     ret = aclmdlLoadFromFile(modelPath, &modelId);
     EXPECT_NE(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadDataFromFile(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromDataWithArgs(_,_,_))
         .WillOnce(Return((PARAM_INVALID)));
     ret = aclmdlLoadFromFile(modelPath, &modelId);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -600,13 +621,13 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromFileRTV2)
     uint32_t modelId = 1;
     const char *modelPath = "/";
     // case 1
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataSuccess));
     auto ret = aclmdlLoadFromFile(modelPath, &modelId);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
     // case 2
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataReturnError));
     ret = aclmdlLoadFromFile(modelPath, &modelId);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -630,13 +651,13 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromFileWithMemRTV2)
     void *weightPtr = reinterpret_cast<void *>(0x02);
     size_t weightSize = 10U;
     // case 1
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataSuccess));
     auto ret = aclmdlLoadFromFileWithMem(modelPath, &modelId, nullptr, 0U, weightPtr, weightSize);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
     // case 2
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataReturnError));
     ret = aclmdlLoadFromFileWithMem(modelPath, &modelId, nullptr, 0U, weightPtr, weightSize);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -662,7 +683,7 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromMemRTV2)
     head.model_num = 2U;
     void *model = (void *)&head;
     uint32_t modelId = 1;
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataSuccess));
     ret = aclmdlLoadFromMem(model, 0, &modelId);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -670,7 +691,7 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromMemRTV2)
     ret = aclmdlLoadFromMem(model, sizeof(head), &modelId);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
         .WillOnce(Invoke(LoadExecutorFromModelDataReturnError));
     ret = aclmdlLoadFromMem(model, sizeof(head), &modelId);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -696,13 +717,13 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromMemWithMemRTV2)
     EXPECT_NE(ret, ACL_SUCCESS);
 
     // case 3
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataSuccess));
     ret = aclmdlLoadFromMemWithMem(model, sizeof(head), &modelId, nullptr, 0U, weightPtr, weightSize);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
     // case 4
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataReturnError));
     ret = aclmdlLoadFromMemWithMem(model, sizeof(head), &modelId, nullptr, 0U, weightPtr, weightSize);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -721,7 +742,7 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromFileWithMem)
     ret = aclmdlLoadFromFileWithMem(modelPath, &modelId, nullptr, 0, nullptr, 0);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromData(_,_,_,_,_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromDataWithArgs(_,_,_))
         .WillOnce(Return((PARAM_INVALID)));
     ret = aclmdlLoadFromFileWithMem(modelPath, &modelId, nullptr, 0, nullptr, 0);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -749,7 +770,7 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromMem)
     ret = aclmdlLoadFromMem(model, sizeof(head), &modelId);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromData(_,_,_,_,_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromDataWithArgs(_,_,_))
         .WillOnce(Return((PARAM_INVALID)));
     ret = aclmdlLoadFromMem(model, sizeof(head), &modelId);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -768,7 +789,7 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromMemWithMem)
     ret = aclmdlLoadFromMemWithMem(model, 1, &modelId, nullptr, 0, nullptr, 0);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromData(_,_,_,_,_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromDataWithArgs(_,_,_))
         .WillOnce(Return((PARAM_INVALID)));
     ret = aclmdlLoadFromMemWithMem(model, 1, &modelId, nullptr, 0, nullptr, 0);
     EXPECT_NE(ret, ACL_SUCCESS);
@@ -787,20 +808,20 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromFileWithQ)
     ret = aclmdlLoadFromFileWithQ(modelPath, &modelId, input, 1, output, 1);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelWithQ(_,_,_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelWithQ(_,_,_))
         .WillOnce(Return((PARAM_INVALID)));
     ret = aclmdlLoadFromFileWithQ(modelPath, &modelId, input, 1, output, 1);
     EXPECT_NE(ret, ACL_SUCCESS);
-    delete []input;
-    delete []output;
 
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadDataFromFile(_,_))
         .WillOnce(Return((PARAM_INVALID)));
-    ret = aclmdlLoadFromFileWithQ(modelPath, &modelId, (uint32_t*)0x1, 1, (uint32_t*)0x2, 1);
+    ret = aclmdlLoadFromFileWithQ(modelPath, &modelId, (uint32_t*)input, 1, (uint32_t*)output, 1);
     EXPECT_NE(ret, ACL_SUCCESS);
 
-    ret = aclmdlLoadFromFileWithQ(modelPath, &modelId, (uint32_t*)0x1, 0, (uint32_t*)0x2, 1);
+    ret = aclmdlLoadFromFileWithQ(modelPath, &modelId, (uint32_t*)input, 0, (uint32_t*)output, 1);
     EXPECT_NE(ret, ACL_SUCCESS);
+    delete []input;
+    delete []output;
 }
 
 TEST_F(UTEST_ACL_Model, aclmdlLoadFromMemWithQ)
@@ -815,18 +836,18 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadFromMemWithQ)
     ret = aclmdlLoadFromMemWithQ(modelPath, 1, &modelId, input, 1, output, 1);
     EXPECT_EQ(ret, ACL_SUCCESS);
 
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelWithQ(_,_,_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelWithQ(_,_,_))
         .WillRepeatedly(Return(PARAM_INVALID));
     ret = aclmdlLoadFromMemWithQ(modelPath, 1, &modelId, input, 1, output, 1);
     EXPECT_NE(ret, ACL_SUCCESS);
 
-    delete []input;
-    delete []output;
-
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelWithQ(_,_,_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelWithQ(_,_,_))
         .WillRepeatedly(Return(PARAM_INVALID));
     ret = aclmdlLoadFromMemWithQ(modelPath, 0, &modelId, input, 1, output, 1);
     EXPECT_NE(ret, ACL_SUCCESS);
+
+    delete []input;
+    delete []output;
 }
 
 TEST_F(UTEST_ACL_Model, aclmdlUnload)
@@ -2358,6 +2379,184 @@ TEST_F(UTEST_ACL_Model, aclGetTensorDescAddress)
     EXPECT_EQ(ret, nullptr);
 }
 
+TEST_F(UTEST_ACL_Model, aclmdlSetExternalWeightAddress) {
+    aclmdlConfigHandle *handle = aclmdlCreateConfigHandle();
+    ASSERT_NE(handle, nullptr);
+    std::string file_name = "fileconstant1.bin";
+    size_t mem_size = 1024;
+    uint32_t user_mem[1024];
+    auto ret = aclmdlSetExternalWeightAddress(handle, file_name.c_str(), (void *)user_mem, mem_size);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    ret = aclmdlSetExternalWeightAddress(handle, file_name.c_str(), nullptr, mem_size);
+    EXPECT_NE(ret, ACL_SUCCESS);
+    ret = aclmdlSetExternalWeightAddress(handle, nullptr, (void *)user_mem, mem_size);
+    EXPECT_NE(ret, ACL_SUCCESS);
+    ret = aclmdlSetExternalWeightAddress(nullptr, file_name.c_str(), (void *)user_mem, mem_size);
+    EXPECT_NE(ret, ACL_SUCCESS);
+    ret = aclmdlSetExternalWeightAddress(handle, file_name.c_str(), (void *)user_mem, 0);
+    EXPECT_NE(ret, ACL_SUCCESS);
+    aclmdlDestroyConfigHandle(handle);
+}
+
+TEST_F(UTEST_ACL_Model, aclmdlLoadWithConfig_ExternalAddress)
+{
+    aclmdlConfigHandle *handle = aclmdlCreateConfigHandle();
+    ASSERT_NE(handle, nullptr);
+    std::string file_name1 = "fileconstant1.bin";
+    size_t mem_size1 = 1024;
+    uint32_t user_mem1[1024];
+    auto ret = aclmdlSetExternalWeightAddress(handle, file_name1.c_str(), (void *)user_mem1, mem_size1);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    std::string file_name2 = "fileconstant2.bin";
+    size_t mem_size2 = 1024;
+    uint32_t user_mem2[1024];
+    ret = aclmdlSetExternalWeightAddress(handle, file_name2.c_str(), (void *)user_mem2, mem_size2);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    ge::ModelFileHeader head;
+    head.version = ge::MODEL_VERSION + 1U;
+    head.model_num = 2U;
+    void *p = (void *)&head;
+    uint32_t modelId;
+    size_t type = 99;
+
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_MEM_ADDR_PTR, &p, sizeof(p));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    size_t modelSize1 = 1;
+    size_t modelSize = sizeof(head);
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_MEM_SIZET, &modelSize, sizeof(modelSize));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    const char *path = "/home";
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_PATH_PTR, &path, sizeof(path));
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_WORKSPACE_ADDR_PTR, &p, sizeof(p));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_WORKSPACE_SIZET, &modelSize1, sizeof(modelSize1));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_WEIGHT_ADDR_PTR, &p, sizeof(p));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_WEIGHT_SIZET, &modelSize1, sizeof(modelSize1));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    size_t reuseMemory = 0;
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_WORKSPACE_MEM_OPTIMIZE, &reuseMemory, sizeof(reuseMemory));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    reuseMemory = 0xFFFFFFFFFFFFFFFF;
+
+    vector<uint32_t> inputQ(100);
+    vector<uint32_t> outputQ(100);
+    uint32_t *inputQPtr = inputQ.data();
+    uint32_t *outputQPtr = outputQ.data();
+
+    type = ACL_MDL_LOAD_FROM_FILE_WITH_Q;
+
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_INPUTQ_ADDR_PTR, &inputQPtr, sizeof(inputQ.data()));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    size_t num = 100;
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_INPUTQ_NUM_SIZET, &num, sizeof(size_t));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_OUTPUTQ_ADDR_PTR, &outputQPtr, sizeof(outputQ.data()));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_OUTPUTQ_NUM_SIZET, &num, sizeof(size_t));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    int32_t priority = 1;
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_PRIORITY_INT32, &priority, sizeof(priority));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    type = ACL_MDL_LOAD_FROM_MEM;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    // rt2.0
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
+        .WillRepeatedly(Invoke(LoadExecutorFromModelDataCheckFileConstantMemSuccess));
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = false;
+
+    type = ACL_MDL_LOAD_FROM_MEM_WITH_MEM;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    // static
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    // rt2.0
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = false;
+    // static
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    type = ACL_MDL_LOAD_FROM_FILE_WITH_MEM;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    // rt2.0
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = false;
+
+    type = ACL_MDL_LOAD_FROM_FILE;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    // rt2.0
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = false;
+
+    type = ACL_MDL_LOAD_FROM_FILE_WITH_Q;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    type = ACL_MDL_LOAD_FROM_MEM_WITH_Q;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    type = ACL_MDL_LOAD_FROM_MEM;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    const char_t *weight_path = "weight_path";
+    aclmdlSetConfigOpt(handle, ACL_MDL_WEIGHT_PATH_PTR, &weight_path, sizeof(weight_path));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    type = ACL_MDL_LOAD_FROM_FILE;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    const char *om_path = "/home";
+    ret = aclmdlSetConfigOpt(handle, ACL_MDL_PATH_PTR, &om_path, sizeof(om_path));
+    EXPECT_EQ(ret, ACL_SUCCESS);
+
+    type = ACL_MDL_LOAD_FROM_MEM_WITH_MEM;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_NE(ret, ACL_SUCCESS);
+
+    type = ACL_MDL_LOAD_FROM_MEM;
+    aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
+    // rt2.0
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
+        .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
+    ret = aclmdlLoadWithConfig(handle, &modelId);
+    EXPECT_EQ(ret, ACL_SUCCESS);
+    acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = false;
+    aclmdlDestroyConfigHandle(handle);
+}
+
 TEST_F(UTEST_ACL_Model, aclmdlLoadWithConfig)
 {
     aclmdlConfigHandle *handle = aclmdlCreateConfigHandle();
@@ -2494,7 +2693,7 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadWithConfig)
     ret = aclmdlLoadWithConfig(handle, &modelId);
     EXPECT_EQ(ret, ACL_SUCCESS);
     // rt2.0
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
     acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
     ret = aclmdlLoadWithConfig(handle, &modelId);
@@ -2569,7 +2768,7 @@ TEST_F(UTEST_ACL_Model, aclmdlLoadWithConfig)
     type = ACL_MDL_LOAD_FROM_MEM;
     aclmdlSetConfigOpt(handle, ACL_MDL_LOAD_TYPE_SIZET, &type, sizeof(type));
     // rt2.0
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
     acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
     ret = aclmdlLoadWithConfig(handle, &modelId);
@@ -3327,7 +3526,7 @@ TEST_F(UTEST_ACL_Model, RuntimeV2ExecuteWithNullOutput)
 
     uint32_t modelId = 1;
     const char *modelPath = "/";
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
     .WillOnce(Invoke(LoadExecutorFromModelDataSuccess));
     auto ret = aclmdlLoadFromFile(modelPath, &modelId);
     EXPECT_EQ(ret, ACL_SUCCESS);
@@ -3385,7 +3584,7 @@ TEST_F(UTEST_ACL_Model, RuntimeV2LoadFromFile)
 
     uint32_t modelId = 1;
     const char *modelPath = "/";
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
             .WillOnce(Invoke(LoadExecutorFromModelDataSuccess));
     auto ret = aclmdlLoadFromFile(modelPath, &modelId);
     EXPECT_EQ(ret, ACL_SUCCESS);
@@ -3402,7 +3601,7 @@ TEST_F(UTEST_ACL_Model, RuntimeV2LoadFromFileFailed)
     acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
     uint32_t modelId = 1;
     const char *modelPath = "/";
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
         .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), IsDynamicModel(_,_))
         .WillRepeatedly(Invoke((IsDynamicModelReturnTrue)));
@@ -3426,7 +3625,7 @@ TEST_F(UTEST_ACL_Model, RuntimeV2LoadFromMemFailed)
     head.version = ge::MODEL_VERSION + 1U;
     head.model_num = 2U;
     void *model = (void *)&head;
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_))
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
         .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamCreate(_,_))
         .WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
@@ -3787,8 +3986,8 @@ TEST_F(UTEST_ACL_Model, TestaclmdlBundleLoadFromMem_success)
     auto model_p = ConstructBundleOm(3, size);
     uint8_t * model_data = model_p.get();
     acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelDataWithRtSession(_,_,_))
-            .WillRepeatedly(Invoke(LoadExecutorFromModelDataWithRtSessionSuccess));
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
+            .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
     auto ret = aclmdlBundleLoadFromMem(model_data, size, &bundle_id);
     EXPECT_EQ(ret , ACL_SUCCESS);
     ret = aclmdlBundleUnload(bundle_id);
@@ -3821,8 +4020,8 @@ TEST_F(UTEST_ACL_Model, TestaclmdlBundleLoadFromFile)
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadDataFromFileV2(_,_))
             .WillOnce(Return(ge::GRAPH_FAILED))
             .WillRepeatedly(Invoke(LoadDataFromFileV2Stub));
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelDataWithRtSession(_,_,_))
-            .WillRepeatedly(Invoke(LoadExecutorFromModelDataWithRtSessionSuccess));
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
+            .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromDataWithArgs(_,_,_))
             .WillOnce(Return(ge::GRAPH_FAILED))
             .WillRepeatedly(Return(ge::SUCCESS));
@@ -3864,8 +4063,8 @@ TEST_F(UTEST_ACL_Model, TestBundleInfo)
     auto model_p = ConstructBundleOm(3, size);
     uint8_t * model_data = model_p.get();
     acl::AclResourceManager::GetInstance().enableRuntimeV2ForModel_ = true;
-    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelDataWithRtSession(_,_,_))
-            .WillRepeatedly(Invoke(LoadExecutorFromModelDataWithRtSessionSuccess));
+    EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadExecutorFromModelData(_,_,_))
+            .WillRepeatedly(Invoke(LoadExecutorFromModelDataSuccess));
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), LoadModelFromDataWithArgs(_,_,_))
             .WillRepeatedly(Invoke(LoadModelFromDataWithArgsStub));
     auto ret = aclmdlBundleLoadFromMem(model_data, size, &bundle_id);
diff --git a/tests/ut/acl/testcase/acl_runtime_unittest.cpp b/tests/ut/acl/testcase/acl_runtime_unittest.cpp
index e51fbf0c6a3d46816545a12dc23ecca46fef35ca..b0a00bc274dabc86e61656ea2905a7d4ca359898 100755
--- a/tests/ut/acl/testcase/acl_runtime_unittest.cpp
+++ b/tests/ut/acl/testcase/acl_runtime_unittest.cpp
@@ -829,13 +829,13 @@ TEST_F(UTEST_ACL_Runtime, aclrtQueryEventTest)
 
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQuery(_))
         .WillOnce(Return((ACL_ERROR_RT_EVENT_NOT_COMPLETE)));
-    ret =  aclrtQueryEvent(event, &status);
+    ret =  aclrtQueryEvent(&event, &status);
     EXPECT_EQ(ret, ACL_SUCCESS);
     EXPECT_EQ(status, ACL_EVENT_STATUS_NOT_READY);
 
     EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQuery(_))
         .WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
-    ret = aclrtQueryEvent(event, &status);
+    ret = aclrtQueryEvent(&event, &status);
     EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
 }
 
diff --git a/third_party/cann-graph-engine b/third_party/cann-graph-engine
index 4231614c2552445c3ebd6432d8c1a7c9b28a73f5..f15250ed4eae9ce6bb910556b293e57c65077757 160000
--- a/third_party/cann-graph-engine
+++ b/third_party/cann-graph-engine
@@ -1 +1 @@
-Subproject commit 4231614c2552445c3ebd6432d8c1a7c9b28a73f5
+Subproject commit f15250ed4eae9ce6bb910556b293e57c65077757