Merge branch 'development' of https://gitee.com/mindspore/graphengine into add_switch_merge_pass_in_prepare

4 years ago · d0452f2e0d
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,6 +13,12 @@ if(DEFINED ENV{ASCEND_CUSTOM_PATH})
 else()
    set(ASCEND_DIR /usr/local/Ascend)
 endif()

 if(DEFINED ENV{D_PKG_SERVER})
    set(GE_PB_PKG $ENV{D_PKG_SERVER})
    message("Download packages from PKG server")
 endif()

 set(ASCEND_DRIVER_DIR ${ASCEND_DIR}/driver/lib64)
 set(ASCEND_DRIVER_COMMON_DIR ${ASCEND_DIR}/driver/lib64/common)
 set(ASCEND_DRIVER_SHARE_DIR ${ASCEND_DIR}/driver/lib64/share)
--- a/build.sh
+++ b/build.sh
@@ -202,25 +202,25 @@ echo "---------------- GraphEngine output generated ----------------"
 #     cp ${BUILD_PATH}/graphengine/tests/st/st_resnet50_train ${OUTPUT_PATH}
 # fi

 # if [[ "X$ENABLE_GE_UT" = "Xon" || "X$ENABLE_GE_COV" = "Xon" ]]; then
 #     cp ${BUILD_PATH}/graphengine/tests/ut/common/graph/ut_libgraph ${OUTPUT_PATH}
 #     cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_multiparts_utest ${OUTPUT_PATH}
 #     cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_distinct_load_utest ${OUTPUT_PATH}
 #     cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_others_utest ${OUTPUT_PATH}
 #     cp ${BUILD_PATH}/graphengine/tests/ut/ge/ut_libge_kernel_utest ${OUTPUT_PATH}
 if [[ "X$ENABLE_GE_UT" = "Xon" || "X$ENABLE_GE_COV" = "Xon" ]]; then
    cp ${BUILD_PATH}/tests/ut/common/graph/ut_libgraph ${OUTPUT_PATH}
    cp ${BUILD_PATH}/tests/ut/ge/ut_libge_multiparts_utest ${OUTPUT_PATH}
    cp ${BUILD_PATH}/tests/ut/ge/ut_libge_distinct_load_utest ${OUTPUT_PATH}
    cp ${BUILD_PATH}/tests/ut/ge/ut_libge_others_utest ${OUTPUT_PATH}
    cp ${BUILD_PATH}/tests/ut/ge/ut_libge_kernel_utest ${OUTPUT_PATH}

 #     if [[ "X${ENABLE_GE_UT_ONLY_COMPILE}" != "Xon" ]]; then
 #         export LD_LIBRARY_PATH=${D_LINK_PATH}/x86_64/:${BUILD_PATH}../third_party/prebuild/x86_64/:${BUILD_PATH}/graphengine/:/usr/local/HiAI/driver/lib64:/usr/local/HiAI/runtime/lib64:${LD_LIBRARY_PATH}
 #         echo ${LD_LIBRARY_PATH}
 #         ${OUTPUT_PATH}/ut_libgraph &&
 #         ${OUTPUT_PATH}/ut_libge_multiparts_utest &&
 #         ${OUTPUT_PATH}/ut_libge_distinct_load_utest &&
 #         ${OUTPUT_PATH}/ut_libge_others_utest &&
 #         ${OUTPUT_PATH}/ut_libge_kernel_utest
 #         if [[ "$?" -ne 0 ]]; then
 #             echo "!!! UT FAILED, PLEASE CHECK YOUR CHANGES !!!"
 #             exit 1;
 #         fi
    ${OUTPUT_PATH}/ut_libgraph &&
    ${OUTPUT_PATH}/ut_libge_multiparts_utest &&
    ${OUTPUT_PATH}/ut_libge_distinct_load_utest &&
    ${OUTPUT_PATH}/ut_libge_others_utest &&
    ${OUTPUT_PATH}/ut_libge_kernel_utest
    if [[ "$?" -ne 0 ]]; then
        echo "!!! UT FAILED, PLEASE CHECK YOUR CHANGES !!!"
        exit 1;
    fi
 #     fi

 #     if [[ "X$ENABLE_GE_COV" = "Xon" ]]; then
@@ -230,7 +230,7 @@ echo "---------------- GraphEngine output generated ----------------"
 #         mkdir ${BASEPATH}/cov
 #         gcovr -r ./ --exclude 'third_party' --exclude 'build' --exclude 'tests' --exclude 'prebuild' --exclude 'inc' --print-summary --html --html-details -d -o cov/index.html
 #     fi
 # fi
 fi

 # generate output package in tar form, including ut/st libraries/executables
 generate_package()
--- a/cmake/external_libs/json.cmake
+++ b/cmake/external_libs/json.cmake
@@ -5,15 +5,15 @@ endif()
 include(ExternalProject)

 set(JSON_SRC_DIR ${CMAKE_BINARY_DIR}/opensrc/json/include)
 if (ENABLE_GITEE)
    set(REQ_URL "https://gitee.com/mirrors/JSON-for-Modern-CPP/repository/archive/v3.6.1.zip")
    set(MD5 "5bda78ce308e6cfcf614dcf1d5ff27a7")
    set(JSON_INCLUDE_DIR "${JSON_SRC_DIR}/include")
 else()
    set(REQ_URL "https://github.com/nlohmann/json/releases/download/v3.6.1/include.zip")
    set(MD5 "0dc903888211db3a0f170304cd9f3a89")
    set(JSON_INCLUDE_DIR ${JSON_SRC_DIR})
 endif ()
 #if (ENABLE_GITEE)
 #    set(REQ_URL "https://gitee.com/mirrors/JSON-for-Modern-CPP/repository/archive/v3.6.1.zip")
 #    set(MD5 "5bda78ce308e6cfcf614dcf1d5ff27a7")
 #    set(JSON_INCLUDE_DIR "${JSON_SRC_DIR}/include")
 #else()
 set(REQ_URL "https://github.com/nlohmann/json/releases/download/v3.6.1/include.zip")
 set(MD5 "0dc903888211db3a0f170304cd9f3a89")
 set(JSON_INCLUDE_DIR ${JSON_SRC_DIR})
 #endif ()
 ExternalProject_Add(json_build
                    URL ${REQ_URL}
                    #URL /home/txd/workspace/cloud_code/pkg/include.zip
--- a/cmake/external_libs/protobuf_shared.cmake
+++ b/cmake/external_libs/protobuf_shared.cmake
@@ -10,14 +10,17 @@ if ((${CMAKE_INSTALL_PREFIX} STREQUAL /usr/local) OR
    set(CMAKE_INSTALL_PREFIX ${GE_CODE_DIR}/output CACHE STRING "path for install()" FORCE)
    message(STATUS "No install prefix selected, default to ${CMAKE_INSTALL_PREFIX}.")
 endif()

 if (ENABLE_GITEE)
    set(REQ_URL "https://gitee.com/mirrors/protobuf_source/repository/archive/v3.8.0.tar.gz")
    set(MD5 "eba86ae9f07ba5cfbaf8af3bc4e84236")
 if (GE_PB_PKG)
    set(REQ_URL "${GE_PB_PKG}/libs/protobuf/v3.8.0.tar.gz")
 else()
    set(REQ_URL "https://github.com/protocolbuffers/protobuf/archive/v3.8.0.tar.gz")
    set(MD5 "3d9e32700639618a4d2d342c99d4507a")
 endif ()
    if (ENABLE_GITEE)
        set(REQ_URL "https://gitee.com/mirrors/protobuf_source/repository/archive/v3.8.0.tar.gz")
        set(MD5 "eba86ae9f07ba5cfbaf8af3bc4e84236")
    else()
        set(REQ_URL "https://github.com/protocolbuffers/protobuf/archive/v3.8.0.tar.gz")
        set(MD5 "3d9e32700639618a4d2d342c99d4507a")
    endif ()
 endif()

 set(protobuf_CXXFLAGS "-Wno-maybe-uninitialized -Wno-unused-parameter -fPIC -fstack-protector-all -D_FORTIFY_SOURCE=2 -D_GLIBCXX_USE_CXX11_ABI=0 -O2 -Dgoogle=ascend_private")
 set(protobuf_LDFLAGS "-Wl,-z,relro,-z,now,-z,noexecstack")
--- a/cmake/external_libs/protobuf_static.cmake
+++ b/cmake/external_libs/protobuf_static.cmake
@@ -8,13 +8,17 @@ if ((${CMAKE_INSTALL_PREFIX} STREQUAL /usr/local) OR
    message(STATUS "No install prefix selected, default to ${CMAKE_INSTALL_PREFIX}.")
 endif()

 if (ENABLE_GITEE)
    set(REQ_URL "https://gitee.com/mirrors/protobuf_source/repository/archive/v3.8.0.tar.gz")
    set(MD5 "eba86ae9f07ba5cfbaf8af3bc4e84236")
 if(GE_PB_PKG)
    set(REQ_URL "${GE_PB_PKG}/libs/protobuf/v3.8.0.tar.gz")
 else()
    set(REQ_URL "https://github.com/protocolbuffers/protobuf/archive/v3.8.0.tar.gz")
    set(MD5 "3d9e32700639618a4d2d342c99d4507a")
 endif ()
    if (ENABLE_GITEE)
        set(REQ_URL "https://gitee.com/mirrors/protobuf_source/repository/archive/v3.8.0.tar.gz")
        set(MD5 "eba86ae9f07ba5cfbaf8af3bc4e84236")
    else()
        set(REQ_URL "https://github.com/protocolbuffers/protobuf/archive/v3.8.0.tar.gz")
        set(MD5 "3d9e32700639618a4d2d342c99d4507a")
    endif ()
 endif()

 set(protobuf_CXXFLAGS "-Wno-maybe-uninitialized -Wno-unused-parameter -fPIC -fstack-protector-all -D_FORTIFY_SOURCE=2 -D_GLIBCXX_USE_CXX11_ABI=0 -O2 -Dgoogle=ascend_private")
 set(protobuf_LDFLAGS "-Wl,-z,relro,-z,now,-z,noexecstack")
--- a/cmake/external_libs/protoc.cmake
+++ b/cmake/external_libs/protoc.cmake
@@ -12,14 +12,17 @@ if ((${CMAKE_INSTALL_PREFIX} STREQUAL /usr/local) OR
    message(STATUS "No install prefix selected, default to ${CMAKE_INSTALL_PREFIX}.")
 endif()

 if (ENABLE_GITEE)
    set(REQ_URL "https://gitee.com/mirrors/protobuf_source/repository/archive/v3.8.0.tar.gz")
    set(MD5 "eba86ae9f07ba5cfbaf8af3bc4e84236")
 if(GE_PB_PKG)
    set(REQ_URL "${GE_PB_PKG}/libs/protobuf/v3.8.0.tar.gz")
 else()
    set(REQ_URL "https://github.com/protocolbuffers/protobuf/archive/v3.8.0.tar.gz")
    set(MD5 "3d9e32700639618a4d2d342c99d4507a")
 endif ()

    if (ENABLE_GITEE)
        set(REQ_URL "https://gitee.com/mirrors/protobuf_source/repository/archive/v3.8.0.tar.gz")
        set(MD5 "eba86ae9f07ba5cfbaf8af3bc4e84236")
    else()
        set(REQ_URL "https://github.com/protocolbuffers/protobuf/archive/v3.8.0.tar.gz")
        set(MD5 "3d9e32700639618a4d2d342c99d4507a")
    endif ()
 endif()

 set(protobuf_CXXFLAGS "-Wno-maybe-uninitialized -Wno-unused-parameter -fPIC -fstack-protector-all -D_FORTIFY_SOURCE=2 -D_GLIBCXX_USE_CXX11_ABI=0 -O2")
 set(protobuf_LDFLAGS "-Wl,-z,relro,-z,now,-z,noexecstack")
--- a/ge/common/helper/model_helper.cc
+++ b/ge/common/helper/model_helper.cc
@@ -140,8 +140,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod

  std::shared_ptr<ModelTaskDef> model_task_def = ge_model->GetModelTaskDefPtr();
  if (model_task_def == nullptr) {
    GELOGE(MEMALLOC_FAILED, "Create model task def ptr failed");
    return FAILED;
    GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Create model task def ptr failed");
    return ACL_ERROR_GE_MEMORY_ALLOCATION;
  }
  size_t partition_task_size = model_task_def->ByteSizeLong();
  GE_IF_BOOL_EXEC(partition_task_size == 0 || partition_task_size > INT_MAX,
@@ -150,8 +150,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod

  ge::Buffer task_buffer(partition_task_size);
  if (task_buffer.GetSize() == 0) {
    GELOGE(MEMALLOC_FAILED, "Alloc model task def buffer failed");
    return MEMALLOC_FAILED;
    GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Alloc model task def buffer failed");
    return ACL_ERROR_GE_MEMORY_ALLOCATION;
  }
  (void)model_task_def->SerializePartialToArray(task_buffer.GetData(), static_cast<int>(partition_task_size));

@@ -173,8 +173,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
  err = memcpy_s(model_header.platform_version, PLATFORM_VERSION_LEN, platform_version.c_str(),
                 platform_version.size() + 1);
  if (err != EOK) {
    GELOGE(MEMALLOC_FAILED, "ModelHelper SaveModel failed while allocating memory for platform_version.");
    return MEMALLOC_FAILED;
    GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "ModelHelper SaveModel failed while allocating memory for platform_version.");
    return ACL_ERROR_GE_MEMORY_ALLOCATION;
  }
  string version = reinterpret_cast<char *>(model_header.platform_version);
  GELOGD("Platform version save: %s", version.c_str());
@@ -183,8 +183,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
  name_size = name_size > (MODEL_NAME_LENGTH - 1) ? (MODEL_NAME_LENGTH - 1) : name_size;
  err = memcpy_s(model_header.name, MODEL_NAME_LENGTH, ge_model->GetName().c_str(), name_size);
  if (err != EOK) {
    GELOGE(MEMALLOC_FAILED, "ModelHelper SaveModel failed while allocating memory for name");
    return MEMALLOC_FAILED;
    GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "ModelHelper SaveModel failed while allocating memory for name");
    return ACL_ERROR_GE_MEMORY_ALLOCATION;
  }
  string model_name = reinterpret_cast<char *>(model_header.name);
  GELOGD("Model name save:%s", model_name.c_str());
@@ -299,8 +299,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadModel(c
  auto partition_table = reinterpret_cast<ModelPartitionTable *>(model_addr_tmp_);
  if (partition_table->num == kOriginalOmPartitionNum) {
    model_addr_tmp_ = nullptr;
    GELOGE(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "om model is error,please use executable om model");
    return ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID;
    GELOGE(ACL_ERROR_GE_PARAM_INVALID, "om model is error,please use executable om model");
    return ACL_ERROR_GE_PARAM_INVALID;
  }
  // Encrypt model need to del temp model/no encrypt model don't need to del model
  model_addr_tmp_ = nullptr;
--- a/ge/common/helper/om_file_helper.cc
+++ b/ge/common/helper/om_file_helper.cc
@@ -119,8 +119,8 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint
  // Original model partition include graph-info
  if ((partition_table->num != PARTITION_SIZE) && (partition_table->num != (PARTITION_SIZE - 1)) &&
      (partition_table->num != (PARTITION_SIZE - kOptionalNum)) && (partition_table->num != 1)) {
    GELOGE(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "Invalid partition_table->num:%u", partition_table->num);
    return ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID;
    GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Invalid partition_table->num:%u", partition_table->num);
    return ACL_ERROR_GE_PARAM_INVALID;
  }
  size_t mem_offset = SIZE_OF_MODEL_PARTITION_TABLE(*partition_table);
  GELOGD("ModelPartitionTable num :%u, ModelFileHeader length :%zu, ModelPartitionTable length :%zu",
--- a/ge/common/model_parser/base.cc
+++ b/ge/common/model_parser/base.cc
@@ -101,15 +101,15 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::ParseMo
  // Get data address
  uint8_t *data = reinterpret_cast<uint8_t *>(model.model_data) + sizeof(ModelFileHeader);
  if (file_header->is_encrypt == ModelEncryptType::UNENCRYPTED) {  // Unencrypted model
    GE_CHK_BOOL_RET_STATUS(model.key.empty(), ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION,
    GE_CHK_BOOL_RET_STATUS(model.key.empty(), ACL_ERROR_GE_PARAM_INVALID,
                           "Invalid param. model is unencrypted, but key is not empty.");

    model_data = data;
    model_len = file_header->length;
    GELOGD("Model_len is %u, model_file_head_len is %zu.", model_len, sizeof(ModelFileHeader));
  } else {
    GELOGE(ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Invalid model. ModelEncryptType not supported.");
    res = ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION;
    GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Invalid model. ModelEncryptType not supported.");
    res = ACL_ERROR_GE_PARAM_INVALID;
  }

  return res;
--- a/ge/common/types.cc
+++ b/ge/common/types.cc
@@ -382,6 +382,7 @@ REGISTER_OPTYPE_DEFINE(HCOMBROADCAST, "HcomBroadcast");
 REGISTER_OPTYPE_DEFINE(HCOMALLGATHER, "HcomAllGather");
 REGISTER_OPTYPE_DEFINE(HCOMALLREDUCE, "HcomAllReduce");
 REGISTER_OPTYPE_DEFINE(HCOMREDUCESCATTER, "HcomReduceScatter");
 REGISTER_OPTYPE_DEFINE(HCOMREDUCE, "HcomReduce");
 REGISTER_OPTYPE_DEFINE(HCOMSEND, "HcomSend");
 REGISTER_OPTYPE_DEFINE(HCOMRECEIVE, "HcomReceive");
 REGISTER_OPTYPE_DEFINE(HCOMREMOTEREAD, "HcomRemoteRead");
--- a/ge/graph/build/graph_builder.cc
+++ b/ge/graph/build/graph_builder.cc
@@ -377,7 +377,9 @@ Status GraphBuilder::GetTaskInfo(const ge::ModelBuilder &builder, const ModelPtr
  }

  auto var_manager = VarManager::Instance(session_id);
  auto *get_mem_base = reinterpret_cast<uint8_t *>(reinterpret_cast<uintptr_t>(var_manager->GetVarMemMaxSize()));
  // since var_mem_logic_base_ = graph_mem_max_size_ + kGraphMemoryBuffer in graph_var_manager.cc,
  // get_mem_base should not bigger than kGraphMemoryBuffer
  auto *get_mem_base = reinterpret_cast<uint8_t *>(reinterpret_cast<uintptr_t>(kGraphMemoryBuffer>>1));
  uint8_t *get_weight_mem_base = get_mem_base;
  if (weight_size > 0) {
    get_weight_mem_base = get_mem_base + memory_size + p2p_memory_size;
--- a/ge/graph/build/stream_allocator.cc
+++ b/ge/graph/build/stream_allocator.cc
@@ -49,7 +49,7 @@ inline bool HasContinuousStreamLabel(const ge::OpDescPtr &op_desc, std::string &
 }

 bool IsHcclOp(const string &op_type) {
  const set<string> hccl_op_types({ge::HCOMBROADCAST, ge::HCOMALLGATHER, ge::HCOMALLREDUCE, ge::HCOMREDUCESCATTER});
  const set<string> hccl_op_types({ge::HCOMBROADCAST, ge::HCOMALLGATHER, ge::HCOMALLREDUCE, ge::HCOMREDUCESCATTER, ge::HCOMREDUCE});
  return hccl_op_types.find(op_type) != hccl_op_types.end();
 }
 }  // namespace
--- a/ge/graph/load/new_model_manager/davinci_model.cc
+++ b/ge/graph/load/new_model_manager/davinci_model.cc
@@ -411,7 +411,8 @@ void DavinciModel::CheckHasHcomOp() {
                     (op_desc->GetType() == HCOMALLREDUCE) || (op_desc->GetType() == HCOMSEND) ||
                     (op_desc->GetType() == HCOMRECEIVE) || (op_desc->GetType() == HCOMREDUCESCATTER) ||
                     (op_desc->GetType() == HVDCALLBACKALLREDUCE) || (op_desc->GetType() == HVDCALLBACKALLGATHER) ||
                     (op_desc->GetType() == HVDCALLBACKBROADCAST) || (op_desc->GetType() == HVDWAIT)),
                     (op_desc->GetType() == HVDCALLBACKBROADCAST) || (op_desc->GetType() == HVDWAIT) ||
                     (op_desc->GetType() == HCOMREDUCE)),
                    uint32_t stream_id = static_cast<uint32_t>(op_desc->GetStreamId());
                    (void)hcom_streams_.emplace(stream_id); GELOGD("hcom stream: %u.", stream_id); continue);
  }
--- a/ge/graph/load/new_model_manager/model_manager.cc
+++ b/ge/graph/load/new_model_manager/model_manager.cc
@@ -1044,7 +1044,7 @@ Status ModelManager::GenSessionId(uint64_t &session_id) {
 Status ModelManager::LoadModelOffline(uint32_t &model_id, const ModelData &model, shared_ptr<ModelListener> listener,
                                      void *dev_ptr, size_t mem_size, void *weight_ptr, size_t weight_size) {
  GE_CHK_BOOL_RET_STATUS(model.key.empty() || mmAccess2(model.key.c_str(), M_F_OK) == EN_OK,
 	                 ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID,
 	                 ACL_ERROR_GE_PARAM_INVALID,
                         "input key file path %s is invalid, %s", model.key.c_str(), strerror(errno));
  GenModelId(&model_id);

@@ -1130,7 +1130,7 @@ Status ModelManager::LoadModelWithQ(uint32_t &model_id, const ModelData &model_d
                                    const std::vector<uint32_t> &input_queue_ids,
                                    const std::vector<uint32_t> &output_queue_ids) {
  GE_CHK_BOOL_RET_STATUS(model_data.key.empty() || mmAccess2(model_data.key.c_str(), M_F_OK) == EN_OK,
                         ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID, "input key file path %s is not valid, %s",
                         ACL_ERROR_GE_PARAM_INVALID, "input key file path %s is not valid, %s",
                         model_data.key.c_str(), strerror(errno));

  ModelHelper model_helper;
@@ -1397,8 +1397,8 @@ Status ModelManager::GetModelMemAndWeightSize(const ModelData &model, size_t &me

  auto partition_table = reinterpret_cast<ModelPartitionTable *>(model_data);
  if (partition_table->num == 1) {
    GELOGE(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "om model is error,please use executable om model");
    return ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID;
    GELOGE(ACL_ERROR_GE_PARAM_INVALID, "om model is error,please use executable om model");
    return ACL_ERROR_GE_PARAM_INVALID;
  }
  ModelPartition task_partition;
  if (om_file_helper.GetModelPartition(ModelPartitionType::TASK_INFO, task_partition) != SUCCESS) {
--- a/ge/graph/load/new_model_manager/task_info/hccl_task_info.cc
+++ b/ge/graph/load/new_model_manager/task_info/hccl_task_info.cc
@@ -279,7 +279,7 @@ Status HcclTaskInfo::SetAddrs(const std::shared_ptr<OpDesc> &op_desc,
      output_data_addr = output_data_addrs_.empty() ? nullptr : output_data_addrs_[i];
    }
    kernel_hccl_infos[i].inputDataAddr = input_data_addr;
    if (hccl_type == HCOMALLGATHER || hccl_type == HCOMRECEIVE || hccl_type == HVDCALLBACKALLGATHER) {
    if (hccl_type == HCOMALLGATHER || hccl_type == HCOMRECEIVE || hccl_type == HVDCALLBACKALLGATHER || hccl_type == HCOMREDUCE) {
      kernel_hccl_infos[i].outputDataAddr = output_data_addr;
    } else if (hccl_type == HCOMALLREDUCE || hccl_type == HCOMREDUCESCATTER || hccl_type == HVDCALLBACKALLREDUCE) {
      GE_CHK_STATUS_RET(HcomOmeUtil::GetHcclOperationType(op_desc, op_type),
--- a/ge/graph/manager/graph_manager.cc
+++ b/ge/graph/manager/graph_manager.cc
@@ -131,6 +131,8 @@ const int64_t kInvalidDynaimcDimsType = -1;
 const char *const kSubstrOfGetNextNosinkName = "IteratorGetNext";
 const char *const kShapeDataName = "ascend_mbatch_shape_data";
 const char *const kGetNextName = "IteratorV2";
 const char *const kExtAttrDataNodes = "data_nodes";
 const char *const kExtAttrGetNextNoSink = "getnext_no_sink";

 bool IsTailingOptimization() {
  string is_tailing_optimization_option;
@@ -2484,15 +2486,15 @@ Status GraphManager::CheckAndReleaseMemory(const GeModelPtr &ge_model, const Gra
      GELOGE(RT_FAILED, "[GraphManager:] rtSetDevice failed, modelId=%u, graphId=%u.", model_id, graph_id);
      continue;
    }
    result = GraphLoader::UnloadModel(model_id);
    if (result != SUCCESS) {
      GELOGW("[GraphManager:] unload model failed, modelId=%u, graphId=%u.", model_id, graph_id);
    }
    result = GraphLoader::DestroyAicpuKernel(session_id, model_id);
    if (result != SUCCESS) {
      GELOGW("[GraphManager:] destroy aicpu kernel failed when dynamic memory, modelId=%u, graphId=%u.", model_id,
             graph_id);
    }
    result = GraphLoader::UnloadModel(model_id);
    if (result != SUCCESS) {
      GELOGW("[GraphManager:] unload model failed, modelId=%u, graphId=%u.", model_id, graph_id);
    }
    rt_ret = rtDeviceReset(GetContext().DeviceId());
    if (rt_ret != RT_ERROR_NONE) {
      GELOGE(RT_FAILED, "[GraphManager:] rtDeviceReset failed, modelId=%u, graphId=%u.", model_id, graph_id);
@@ -2731,37 +2733,6 @@ void GraphManager::PreRunThread(GraphManager *graph_manager) {
  }
 }

 Status GraphManager::DistinguishGetNextAndData(ComputeGraphPtr &graph, vector<NodePtr> &data_nodes,
                                               vector<NodePtr> &getnext_nosink_nodes,
                                               vector<NodePtr> &getnext_sink_nodes) {
  GELOGD("Start distinguish getnext and data node.");
  for (NodePtr &input_node : graph->GetDirectNode()) {
    GE_CHECK_NOTNULL(input_node);
    OpDescPtr op_desc = input_node->GetOpDesc();
    GE_CHECK_NOTNULL(op_desc);
    if (op_desc->GetType() == DATA && op_desc->GetName() != kShapeDataName) {
      if (op_desc->GetName().find(kSubstrOfGetNextNosinkName) == string::npos) {
        data_nodes.emplace_back(input_node);
      } else {
        getnext_nosink_nodes.emplace_back(input_node);
      }
    }
    std::string op_type;
    auto ret = GetOriginalType(input_node, op_type);
    if (ret != SUCCESS) {
      GELOGE(FAILED, "Failed to get node %s original type.", input_node->GetName().c_str());
      return FAILED;
    }
    if (op_type == kGetNextName) {
      GELOGD("Name of getnext sink is %s.", op_desc->GetName().c_str());
      getnext_sink_nodes.emplace_back(input_node);
    }
  }
  GELOGI("data count is %zu, getnext nosink count is %zu, getnext sink count is %zu.", data_nodes.size(),
         getnext_nosink_nodes.size(), getnext_sink_nodes.size());
  return SUCCESS;
 }

 void GraphManager::ParseInputsDimsForData(const std::vector<InputTensorInfo> &input_tensor) {
  GELOGD("Start parse input dims from data.");
  for (size_t i = 0; i < input_tensor.size(); ++i) {
@@ -2804,11 +2775,8 @@ Status GraphManager::ParseInputsDims(const std::vector<InputTensorInfo> &input_t
  if (!GetLocalOmgContext().dynamic_node_type.empty()) {
    vector<NodePtr> data_nodes;
    vector<NodePtr> getnext_nosink_nodes;
    vector<NodePtr> getnext_sink_nodes;
    if (DistinguishGetNextAndData(compute_graph_, data_nodes, getnext_nosink_nodes, getnext_sink_nodes) != SUCCESS) {
      GELOGE(PARAM_INVALID, "Failed to distinguish getnext and data node.");
      return PARAM_INVALID;
    }
    data_nodes = compute_graph_->TryGetExtAttr(kExtAttrDataNodes, data_nodes);
    getnext_nosink_nodes = compute_graph_->TryGetExtAttr(kExtAttrGetNextNoSink, getnext_nosink_nodes);
    if (GetLocalOmgContext().dynamic_node_type == DATA) {
      if (getnext_nosink_nodes.empty()) {
        // just data or data+getnext_sink
--- a/ge/graph/manager/graph_manager.h
+++ b/ge/graph/manager/graph_manager.h
@@ -222,8 +222,6 @@ class GraphManager {
                                                const ComputeGraphPtr &compute_graph, uint64_t session_id,
                                                const GEThreadLocalContext &ge_context);
  Status ParseInputsDims(const std::vector<InputTensorInfo> &input_tensor);
  Status DistinguishGetNextAndData(ComputeGraphPtr &graph, vector<NodePtr> &data_nodes,
                                   vector<NodePtr> &getnext_nosink_nodes, vector<NodePtr> &getnext_sink_nodes);
  void ParseInputsDimsForData(const std::vector<InputTensorInfo> &input_tensor);
  Status ParseInputsDimsForGetNexNosinkAndData(const vector<NodePtr> &dynamic_nodes,
                                               const std::vector<InputTensorInfo> &input_tensor);
--- a/ge/graph/manager/util/hcom_util.cc
+++ b/ge/graph/manager/util/hcom_util.cc
@@ -263,7 +263,7 @@ Status HcomOmeUtil::GetHcclRootId(const ge::ConstOpDescPtr &op_desc, int64_t &ro
 Status HcomOmeUtil::GetAllRootId(const ge::ConstOpDescPtr &op_desc,
                                 std::vector<GETaskKernelHcclInfo> &kernel_hccl_infos) {
  GE_CHECK_NOTNULL(op_desc);
  if (op_desc->GetType() == HCOMBROADCAST || op_desc->GetType() == HVDCALLBACKBROADCAST) {
  if (op_desc->GetType() == HCOMBROADCAST || op_desc->GetType() == HVDCALLBACKBROADCAST || op_desc->GetType() == HCOMREDUCE) {
    GELOGI("GetAllRootId Node[%s] opType[%s] get hccl rootId.", op_desc->GetName().c_str(), op_desc->GetType().c_str());
    int64_t root_id = 0;
    Status dmrt = GetHcclRootId(op_desc, root_id);
@@ -281,7 +281,7 @@ Status HcomOmeUtil::GetAllRootId(const ge::ConstOpDescPtr &op_desc,

 bool HcomOmeUtil::IsHCOMOp(const string &op_type) {
  return (op_type == HCOMALLREDUCE) || (op_type == HCOMALLGATHER) || (op_type == HCOMBROADCAST) ||
         (op_type == HCOMSEND) || (op_type == HCOMRECEIVE) || (op_type == HCOMREDUCESCATTER);
         (op_type == HCOMSEND) || (op_type == HCOMRECEIVE) || (op_type == HCOMREDUCESCATTER) || (op_type == HCOMREDUCE);
 }

 bool HcomOmeUtil::IsHorovodOp(const string &op_type) {
--- a/ge/graph/optimize/mem_rw_conflict_optimize.cc
+++ b/ge/graph/optimize/mem_rw_conflict_optimize.cc
@@ -234,7 +234,7 @@ InputRWType GetSingleNodeInputRWTypeByIndex(const Node &node, uint32_t index) {
    return InputRWType::kInvalidRWType;
  }
  if (op_desc->GetType() == HCOMALLREDUCE || op_desc->GetType() == HCOMALLGATHER
      || op_desc->GetType() == HCOMREDUCESCATTER) {
      || op_desc->GetType() == HCOMREDUCESCATTER || op_desc->GetType() == HCOMREDUCE) {
    return InputRWType::kScopeWriteable;
  }
  // check if it is ref input
--- a/ge/graph/passes/mark_agnostic_pass.cc
+++ b/ge/graph/passes/mark_agnostic_pass.cc
@@ -43,7 +43,7 @@ Status MarkAgnosticPass::Run(ComputeGraphPtr graph) {
    if (node_type == REFMERGE || node_type == REFSWITCH) {
      GELOGD("Mark format agnostic for regmerge and refswitch node %s", node->GetName().c_str());
      AttrUtils::SetInt(node->GetOpDesc(), "_format_agnostic", 1);
      AttrUtils::SetListInt(node->GetOpDesc(), "_format_agnostic_except_output", std::vector<int64_t>({1}));
      AttrUtils::SetListInt(node->GetOpDesc(), "_format_agnostic_except_input", std::vector<int64_t>({1}));
      continue;
    }
    if (node_type == MERGE) {
--- a/ge/graph/preprocess/multi_batch_options.cc
+++ b/ge/graph/preprocess/multi_batch_options.cc
@@ -46,6 +46,8 @@ const int kDivisionConst = 2;
 const char *const kSubstrOfGetNextNosinkName = "IteratorGetNext";
 const char *const kShapeDataName = "ascend_mbatch_shape_data";
 const char *const kGetNextName = "IteratorV2";
 const char *const kExtAttrDataNodes = "data_nodes";
 const char *const kExtAttrGetNextNoSink = "getnext_no_sink";

 inline bool IsGetNextType(const NodePtr &node) {
  std::string original_type;
@@ -97,6 +99,9 @@ Status DistinguishGetNextAndData(ComputeGraphPtr &graph, vector<NodePtr> &data_n
  }
  GELOGI("Data count is %zu, getnext nosink count is %zu, getnext sink count is %zu.", data_nodes.size(),
         getnext_nosink_nodes.size(), getnext_sink_nodes.size());
  GE_IF_BOOL_EXEC(!graph->SetExtAttr(kExtAttrDataNodes, data_nodes), GELOGW("Set data nodes attr failed.");)
  GE_IF_BOOL_EXEC(!graph->SetExtAttr(kExtAttrGetNextNoSink, getnext_nosink_nodes),
                  GELOGW("Set getnext nosink nodes attr failed.");)
  return SUCCESS;
 }

--- a/ge/hybrid/common/npu_memory_allocator.cc
+++ b/ge/hybrid/common/npu_memory_allocator.cc
@@ -23,6 +23,8 @@

 namespace ge {
 namespace hybrid {
 size_t kMaxHbmMemorySize = 1024UL * 1024UL * 1024UL * 1024UL; // 1024G

 std::map<uint32_t, std::unique_ptr<NpuMemoryAllocator>> NpuMemoryAllocator::allocators_;
 std::mutex NpuMemoryAllocator::mu_;

@@ -62,6 +64,10 @@ void *NpuMemoryAllocator::Allocate(std::size_t size, AllocationAttr *attr) {
  } else if (mem_type == HOST_DDR) {
    buffer = malloc(allocate_size);
  } else {
    if (allocate_size > kMaxHbmMemorySize) {
      GELOGE(PARAM_INVALID, "Invalid HBM memory size: %zu", allocate_size);
      return nullptr;
    }
    void *try_reuse_addr = nullptr;
    int padding = kDefaultPadding;
    if (attr != nullptr) {
--- a/ge/hybrid/common/tensor_value.cc
+++ b/ge/hybrid/common/tensor_value.cc
@@ -58,6 +58,7 @@ std::unique_ptr<TensorBuffer> TensorBuffer::Create(void *buffer, size_t size) {
 TensorBuffer::~TensorBuffer() {
  if (allocator_ != nullptr && buffer_ != nullptr) {
    allocator_->Deallocate(buffer_, mem_type_);
    buffer_ = nullptr;
  }
 }

--- a/ge/hybrid/executor/hybrid_model_async_executor.cc
+++ b/ge/hybrid/executor/hybrid_model_async_executor.cc
@@ -52,7 +52,7 @@ Status HybridModelAsyncExecutor::EnqueueData(const shared_ptr<InputDataWrapper>
 }

 Status HybridModelAsyncExecutor::Start(const std::shared_ptr<ModelListener> &listener) {
  GELOGD("HybridModelExecutor::Start IN, listener = %p", listener.get());
  GELOGD("HybridModelExecutor::Start IN, has listener = %d", listener != nullptr);
  std::lock_guard<std::mutex> lk(mu_);
  GE_CHK_BOOL_RET_STATUS(!run_flag_, INTERNAL_ERROR, "Model already started.");

@@ -219,11 +219,11 @@ Status HybridModelAsyncExecutor::CopyInputData(const InputData &current_data) {
    auto mem_size = static_cast<uint32_t>(data_size);
    GE_CHK_BOOL_RET_STATUS(mem_size >= data_buf.length,
                           PARAM_INVALID,
                           "input data size(%u) does not match model required size(%u), ret failed.",
                           "input data size(%lu) does not match model required size(%u), ret failed.",
                           data_buf.length,
                           mem_size);

    GELOGI("[IMAS]CopyPlainData memcpy graph_%u type[F] output[%u] memaddr[%p] mem_size[%u] datasize[%u]",
    GELOGI("[IMAS]CopyPlainData memcpy graph_%u type[F] output[%u] memaddr[%p] mem_size[%u] datasize[%lu]",
           model_->root_runtime_param_.graph_id, input_index, input_tensor.GetData(), mem_size, data_buf.length);
    GE_CHK_RT_RET(rtMemcpy(input_tensor.MutableData(),
                           mem_size,
@@ -241,7 +241,7 @@ Status HybridModelAsyncExecutor::InitInputTensors() {
  int input_index = 0;
  for (const auto &input_node : model_->GetRootGraphItem()->GetInputNodes()) {
    GELOGD("Init input[%u], node = %s", input_index, input_node->NodeName().c_str());
    auto output_desc = input_node->op_desc->GetOutputDescPtr(kDataOutputIndex);
    auto output_desc = input_node->MutableOutputDesc(kDataOutputIndex);
    GE_CHECK_NOTNULL(output_desc);
    int64_t tensor_size = 0;
    GE_CHK_GRAPH_STATUS_RET(TensorUtils::GetSize(*output_desc, tensor_size),
--- a/ge/hybrid/executor/node_state.cc
+++ b/ge/hybrid/executor/node_state.cc
@@ -35,39 +35,43 @@ ShapeInferenceState::ShapeInferenceState(const NodeItem &node_item) : node_item(
         this->num_pending_shapes_);
 }

 void ShapeInferenceState::UpdateInputShape(uint32_t idx,
                                           const GeShape &ori_shape,
                                           const GeShape &shape) {
  if (!node_item.is_dynamic || node_item.is_input_shape_static[idx]) {
    GELOGD("[%s] Trying to update static shape, idx = %u. old shape = [%s], new shape = [%s]",
 Status ShapeInferenceState::UpdateInputShape(int idx,
                                             const GeShape &ori_shape,
                                             const GeShape &shape) {
  if (node_item.IsInputShapeStatic(idx)) {
    GELOGD("[%s] Trying to update static shape, idx = %d. old shape = [%s], new shape = [%s]",
           node_item.NodeName().c_str(),
           idx,
           node_item.op_desc->MutableInputDesc(idx)->GetShape().ToString().c_str(),
           node_item.MutableInputDesc(idx)->GetShape().ToString().c_str(),
           shape.ToString().c_str());
    return;
    return SUCCESS;
  }

  GELOGD("[%s] Update input shape [%u] with Shape: [%s] and OriginalShape: [%s]",
  GELOGD("[%s] Update input shape [%d] with Shape: [%s] and OriginalShape: [%s]",
         node_item.NodeName().c_str(),
         idx,
         shape.ToString().c_str(),
         ori_shape.ToString().c_str());

  std::lock_guard<std::mutex> lk(mu_);
  node_item.op_desc->MutableInputDesc(idx)->SetShape(shape);
  node_item.op_desc->MutableInputDesc(idx)->SetOriginShape(ori_shape);
  auto tensor_desc = node_item.MutableInputDesc(idx);
  GE_CHECK_NOTNULL(tensor_desc);
  tensor_desc->SetShape(shape);
  tensor_desc->SetOriginShape(ori_shape);
  if (--num_pending_shapes_ == 0) {
    ready_cv_.notify_all();
  }

  return SUCCESS;
 }

 void ShapeInferenceState::UpdateInputShapeFuture(uint32_t idx, ShapeFuture &&future) {
  if (!node_item.is_dynamic || node_item.is_input_shape_static[idx]) {
    GELOGD("[%s] Trying to update constant shape, idx = %u", node_item.NodeName().c_str(), idx);
 void ShapeInferenceState::UpdateInputShapeFuture(int idx, ShapeFuture &&future) {
  if (node_item.IsInputShapeStatic(idx)) {
    GELOGD("[%s] Trying to update constant shape, idx = %d", node_item.NodeName().c_str(), idx);
    return;
  }

  GELOGD("[%s] Update input shape [%u] with ShapeFuture.", node_item.NodeName().c_str(), idx);
  GELOGD("[%s] Update input shape [%d] with ShapeFuture.", node_item.NodeName().c_str(), idx);
  std::lock_guard<std::mutex> lk(mu_);
  shape_futures.emplace_back(idx, std::move(future));
  if (--num_pending_shapes_ == 0) {
@@ -120,8 +124,10 @@ Status ShapeInferenceState::AwaitShapesReady(const GraphExecutionContext &contex
           idx,
           shape.ToString().c_str(),
           ori_shape.ToString().c_str());
    node_item.op_desc->MutableInputDesc(idx)->SetShape(std::move(shape));
    node_item.op_desc->MutableInputDesc(idx)->SetOriginShape(ori_shape);
    auto input_desc = node_item.MutableInputDesc(idx);
    GE_CHECK_NOTNULL(input_desc);
    input_desc->SetShape(std::move(shape));
    input_desc->SetOriginShape(ori_shape);
  }

  return SUCCESS;
@@ -140,7 +146,7 @@ NodeState::NodeState(const NodeItem &node_item, SubgraphContext *subgraph_contex

 Status NodeState::AwaitInputTensors(GraphExecutionContext &context) const {
  for (auto &src_node : node_item_->dependents_for_execution) {
    GELOGI("[%s] Start to wait for data dependent node: [%s]",
    GELOGD("[%s] Start to wait for data dependent node: [%s]",
           node_item_->NodeName().c_str(),
           src_node->GetName().c_str());
    RECORD_EXECUTION_EVENT(&context,
@@ -156,7 +162,7 @@ Status NodeState::AwaitInputTensors(GraphExecutionContext &context) const {
                           node_item_->NodeName().c_str(),
                           "[AwaitNodeDone] [%s] End",
                           src_node->GetName().c_str());
    GELOGI("[%s] Done waiting node.", src_node->GetName().c_str());
    GELOGD("[%s] Done waiting node.", src_node->GetName().c_str());
  }

  return SUCCESS;
@@ -173,7 +179,7 @@ Status NodeState::WaitForPrepareDone() {
 }

 Status ShapeFuture::Get(GeShape &ori_shape, GeShape &shape) {
  GELOGI("Start to wait node: %s for getting shape", src_node_->GetName().c_str());
  GELOGD("Start to wait node: %s for getting shape", src_node_->GetName().c_str());
  if (!subgraph_context_->Await(src_node_)) {
    GELOGE(INTERNAL_ERROR, "cancelled");
    return INTERNAL_ERROR;
@@ -181,7 +187,7 @@ Status ShapeFuture::Get(GeShape &ori_shape, GeShape &shape) {

  shape = src_node_->GetOpDesc()->MutableOutputDesc(src_index_)->MutableShape();
  ori_shape = src_node_->GetOpDesc()->MutableOutputDesc(src_index_)->GetOriginShape();
  GELOGI("Get shape from %s:%u. shape = [%s]", src_node_->GetName().c_str(), src_index_, shape.ToString().c_str());
  GELOGD("Get shape from %s:%u. shape = [%s]", src_node_->GetName().c_str(), src_index_, shape.ToString().c_str());
  return SUCCESS;
 }
 }  // namespace hybrid
--- a/ge/hybrid/executor/node_state.h
+++ b/ge/hybrid/executor/node_state.h
@@ -45,16 +45,16 @@ class ShapeFuture {
 struct ShapeInferenceState {
  explicit ShapeInferenceState(const NodeItem &node_item);

  void UpdateInputShape(uint32_t idx, const GeShape &ori_shape, const GeShape &shape);
  Status UpdateInputShape(int idx, const GeShape &ori_shape, const GeShape &shape);

  void UpdateInputShapeFuture(uint32_t idx, ShapeFuture &&future);
  void UpdateInputShapeFuture(int idx, ShapeFuture &&future);

  Status AwaitShapesReady(const GraphExecutionContext &context);

  const NodeItem &node_item;

 private:
  std::vector<std::pair<uint32_t, ShapeFuture>> shape_futures;
  std::vector<std::pair<int, ShapeFuture>> shape_futures;
  int num_pending_shapes_ = 0;
  std::condition_variable ready_cv_;
  std::mutex mu_;
--- a/ge/hybrid/executor/worker/execution_engine.cc
+++ b/ge/hybrid/executor/worker/execution_engine.cc
@@ -36,13 +36,13 @@ Status LogInputs(const NodeItem &node_item, const TaskContext &task_context) {
  for (auto i = 0; i < task_context.NumInputs(); ++i) {
    const auto &input_tensor = task_context.GetInput(i);
    GE_CHECK_NOTNULL(input_tensor);
    const auto &tensor_desc = node_item.op_desc->MutableInputDesc(i);
    const auto &tensor_desc = task_context.GetInputDesc(i);
    GE_CHECK_NOTNULL(tensor_desc);
    GELOGD("[%s] Print task args. input[%d] = %s, shape = [%s]",
           node_item.NodeName().c_str(),
           i,
           input_tensor->DebugString().c_str(),
           tensor_desc->MutableShape().ToString().c_str());
           tensor_desc->GetShape().ToString().c_str());
  }

  return SUCCESS;
@@ -52,7 +52,7 @@ Status LogOutputs(const NodeItem &node_item, const TaskContext &task_context) {
  for (auto i = 0; i < task_context.NumOutputs(); ++i) {
    const auto &output_tensor = task_context.GetOutput(i);
    GE_CHECK_NOTNULL(output_tensor);
    const auto &tensor_desc = node_item.op_desc->MutableOutputDesc(i);
    const auto &tensor_desc = node_item.MutableOutputDesc(i);
    GE_CHECK_NOTNULL(tensor_desc);
    GELOGD("[%s] Print task args. output[%d] = %s, shape = [%s]",
           node_item.NodeName().c_str(),
@@ -97,7 +97,7 @@ Status NodeDoneCallback::PrepareConstInputs(const NodeItem &node_item) {
    GE_CHECK_NOTNULL(output_tensor);

    Tensor tensor;
    auto ge_tensor_desc = node_item.op_desc->MutableOutputDesc(output_idx);
    auto ge_tensor_desc = node_item.MutableOutputDesc(output_idx);
    GE_CHECK_NOTNULL(ge_tensor_desc);
    tensor.SetTensorDesc(TensorAdapter::GeTensorDesc2TensorDesc(*ge_tensor_desc));

@@ -107,7 +107,7 @@ Status NodeDoneCallback::PrepareConstInputs(const NodeItem &node_item) {

    if (output_tensor->GetSize() < static_cast<size_t>(tensor_size)) {
      GELOGE(INTERNAL_ERROR,
             "[%s] Tensor size is not enough. output index = %d, required size = %zu, tensor = %s",
             "[%s] Tensor size is not enough. output index = %d, required size = %ld, tensor = %s",
             node_item.NodeName().c_str(),
             output_idx,
             tensor_size,
@@ -453,7 +453,7 @@ Status ExecutionEngine::ValidateInputTensors(const NodeState &node_state, const
      continue;
    }

    const auto &tensor_desc = node_state.GetOpDesc()->MutableInputDesc(i);
    const auto &tensor_desc = task_context.MutableInputDesc(i);
    GE_CHECK_NOTNULL(tensor_desc);
    if (tensor_desc->GetDataType() == DT_STRING) {
      GELOGD("[%s] Skipping DT_STRING input, index = %d", task_context.GetNodeName(), i);
--- a/ge/hybrid/executor/worker/shape_inference_engine.cc
+++ b/ge/hybrid/executor/worker/shape_inference_engine.cc
@@ -142,12 +142,15 @@ Status ShapeInferenceEngine::PropagateOutputShapes(const NodeItem &node_item) {
             dst_input_index_and_node.first);

      // in case type 3 and 4, shape will be valid after computing is done
      auto &infer_state = dst_node_state->GetShapeInferenceState();
      if (shape_is_future) {
        ShapeFuture future(node_item.node, i, subgraph_context_);
        dst_node_state->GetShapeInferenceState().UpdateInputShapeFuture(dst_input_index_and_node.first,
                                                                        std::move(future));
        infer_state.UpdateInputShapeFuture(dst_input_index_and_node.first,
                                           std::move(future));
      } else {
        dst_node_state->GetShapeInferenceState().UpdateInputShape(dst_input_index_and_node.first, ori_shape, shape);
        GE_CHK_STATUS_RET_NOLOG(infer_state.UpdateInputShape(dst_input_index_and_node.first,
                                                             ori_shape,
                                                             shape));
      }
    }
  }
@@ -159,7 +162,7 @@ Status ShapeInferenceEngine::PropagateOutputShapes(const NodeItem &node_item) {
 Status ShapeInferenceEngine::InferShapeForSubgraph(const NodeItem &node_item, const FusedSubgraph &fused_subgraph) {
  GELOGD("[%s] Start to infer shape by fused subgraph", node_item.NodeName().c_str());
  for (auto &it : fused_subgraph.input_mapping) {
    auto parent_tensor_desc = node_item.op_desc->MutableInputDesc(it.first);
    auto parent_tensor_desc = node_item.MutableInputDesc(it.first);
    GE_CHECK_NOTNULL(parent_tensor_desc);
    GELOGD("Start to update shape by input[%u]", it.first);
    GELOGD("Update shape to [%s]", parent_tensor_desc->GetShape().ToString().c_str());
--- a/ge/hybrid/model/graph_item.cc
+++ b/ge/hybrid/model/graph_item.cc
@@ -40,11 +40,11 @@ Status GraphItem::GetOutputDescList(vector<ConstGeTensorDescPtr> &output_desc_li
  }

  if (is_dynamic_) {
    for (auto &tensor_desc : output_node_->op_desc->GetAllInputsDescPtr()) {
    for (auto &tensor_desc : output_node_->GetOpDesc()->GetAllInputsDescPtr()) {
      output_desc_list.emplace_back(tensor_desc);
    }
  } else {
    for (auto &tensor_desc : output_node_->op_desc->GetAllOutputsDescPtr()) {
    for (auto &tensor_desc : output_node_->GetOpDesc()->GetAllOutputsDescPtr()) {
      output_desc_list.emplace_back(tensor_desc);
    }
  }
--- a/ge/hybrid/model/hybrid_model.cc
+++ b/ge/hybrid/model/hybrid_model.cc
@@ -44,7 +44,7 @@ Status HybridModel::Init() {
 TensorValue* HybridModel::GetVariable(const string &name) const {
  auto it = variable_tensors_.find(name);
  if (it == variable_tensors_.end()) {
    GELOGI("Failed to get variable tensor. var name = [%s]", name.c_str());
    GELOGD("Failed to get variable tensor. var name = [%s]", name.c_str());
    return nullptr;
  }

@@ -61,7 +61,7 @@ NodePtr HybridModel::GetVariableNode(const string &name) const {
  if (host_find != host_variable_nodes_.end()) {
    return host_find->second;
  }
  GELOGI("Failed to get variable node by name = [%s]", name.c_str());
  GELOGD("Failed to get variable node by name = [%s]", name.c_str());
  return nullptr;
 }

--- a/ge/hybrid/model/hybrid_model_builder.cc
+++ b/ge/hybrid/model/hybrid_model_builder.cc
@@ -19,14 +19,12 @@
 #include "common/math/math_util.h"
 #include "graph/ge_context.h"
 #include "graph/build/memory/var_mem_assign_util.h"
 #include "graph/utils/node_utils.h"
 #include "graph/debug/ge_attr_define.h"
 #include "graph/load/new_model_manager/model_utils.h"
 #include "graph/manager/graph_var_manager.h"
 #include "graph/manager/host_mem_manager.h"
 #include "graph/manager/trans_var_data_utils.h"
 #include "graph/utils/graph_utils.h"
 #include "graph/utils/type_utils.h"
 #include "hybrid/common/npu_memory_allocator.h"
 #include "hybrid/node_executor/node_executor.h"

@@ -44,20 +42,14 @@ int64_t CalcVarSizeInBytes(const GeTensorDesc &desc) {
  auto data_type = desc.GetDataType();
  if (data_type == DT_STRING) {
    (void) TensorUtils::GetSize(desc, var_size);
  } else {
    var_size = GetSizeByDataType(data_type);
    if (var_size <= 0) {
      GELOGW("Failed to calc var data size from data type %s", TypeUtils::DataTypeToSerialString(data_type).c_str());
      return -1;
    }
    auto shape = desc.GetShape();
    auto dim_num = shape.GetDimNum();
    for (size_t dim_index = 0; dim_index < dim_num; ++dim_index) {
      var_size *= shape.GetDim(dim_index);
    }
    // padding up to multiple of kAlignment, and add extra kAlignment
    var_size = (var_size + kAlignment * 2 - 1) / kAlignment * kAlignment;
    return var_size;
  }

  if (TensorUtils::GetTensorMemorySizeInBytes(desc, var_size) != GRAPH_SUCCESS) {
    GELOGW("Failed to calc var data size");
    return -1;
  }

  return var_size;
 }

@@ -150,7 +142,12 @@ Status HybridModelBuilder::BuildNodeItem(const NodePtr &node, NodeItem &node_ite
      GE_CHK_STATUS_RET(GetOrCreateNodeItem(dst_node, &dst_node_item),
                        "[%s] Failed to get or create node item.",
                        dst_node->GetName().c_str());
      node_item.outputs[i].emplace_back(dst_in_anchor->GetIdx(), dst_node_item);
      int canonical_index;
      GE_CHK_STATUS_RET(dst_node_item->GetCanonicalInputIndex(dst_in_anchor->GetIdx(), canonical_index),
                        "[%s] Failed to canonical input index",
                        dst_node->GetName().c_str());

      node_item.outputs[i].emplace_back(canonical_index, dst_node_item);
    }
  }

@@ -171,7 +168,8 @@ Status HybridModelBuilder::ResolveRefIo(NodeItem &node_item) {
  for (auto &output : outputs) {
    for (auto &input : inputs) {
      if (input.first == output.first) {
        auto input_idx = static_cast<int>(input.second);
        int input_idx;
        GE_CHK_STATUS_RET_NOLOG(node_item.GetCanonicalInputIndex(input.second, input_idx));
        auto output_idx = static_cast<int>(output.second);
        node_item.reuse_inputs[output_idx] = input_idx;
        GELOGD("[%s] Output[%d] reuse input[%d]", node_item.NodeName().c_str(), output_idx, input_idx);
@@ -190,10 +188,8 @@ Status HybridModelBuilder::GetOrCreateNodeItem(const NodePtr &node, NodeItem **n
    return SUCCESS;
  }

  auto new_node = std::unique_ptr<NodeItem>(new(std::nothrow) NodeItem(node));
  GE_CHECK_NOTNULL(new_node);
  GE_CHECK_NOTNULL(new_node->op_desc);
  GE_CHK_STATUS_RET(new_node->Init(), "Failed to init NodeItem [%s] .", node->GetName().c_str());
  std::unique_ptr<NodeItem> new_node;
  GE_CHK_STATUS_RET(NodeItem::Create(node, new_node), "Failed to create node item");
  GE_CHK_STATUS_RET_NOLOG(NodeExecutorManager::GetInstance().GetExecutor(*node, &new_node->node_executor));

  // we do not need L2 Buffer
@@ -202,10 +198,6 @@ Status HybridModelBuilder::GetOrCreateNodeItem(const NodePtr &node, NodeItem **n
  (void) AttrUtils::SetBool(new_node->op_desc, kIsFirstNode, false);
  (void) AttrUtils::SetBool(new_node->op_desc, kIsLastNode, false);

  if (new_node->is_dynamic && (new_node->IsControlOp() || new_node->NodeType() == PARTITIONEDCALL)) {
    new_node->shape_inference_type = DEPEND_COMPUTE;
  }

  new_node->node_id = node_index;
  new_node->op_desc->SetId(node_index);
  node_index += 1;
@@ -446,7 +438,6 @@ Status HybridModelBuilder::MergeInputNodes(ComputeGraph &graph) {
    if (src_out_anchor == nullptr || src_out_anchor->GetOwnerNode() == nullptr) {
      continue;
    }
    auto src_node = wrapped_node_in_anchor->GetPeerOutAnchor()->GetOwnerNode();
    wrapped_node_in_anchor->UnlinkAll();

    // link src to outputs of DataNode
@@ -454,6 +445,7 @@ Status HybridModelBuilder::MergeInputNodes(ComputeGraph &graph) {
      GE_CHECK_NOTNULL(out_data_anchor);
      for (auto &peer_in_data_anchor : out_data_anchor->GetPeerInDataAnchors()) {
        auto dst_node = peer_in_data_anchor->GetOwnerNode();
        GE_CHECK_NOTNULL(dst_node);
        root_nodes.emplace(dst_node);
        GE_CHK_STATUS_RET_NOLOG(DoUnlinkDataAnchors(out_data_anchor, peer_in_data_anchor));
        GE_CHK_STATUS_RET_NOLOG(DoLinkDataAnchors(src_out_anchor, peer_in_data_anchor));
@@ -496,6 +488,7 @@ Status HybridModelBuilder::MergeNetOutputNode(ComputeGraph &graph) {
  for (const auto &in_data_anchor : net_output_node->GetAllInDataAnchors()) {
    auto src_out_anchor = in_data_anchor->GetPeerOutAnchor();
    GE_CHECK_NOTNULL(src_out_anchor);
    GE_CHECK_NOTNULL(src_out_anchor->GetOwnerNode());
    GE_CHK_STATUS_RET_NOLOG(DoUnlinkDataAnchors(src_out_anchor, in_data_anchor));

    auto index = in_data_anchor->GetIdx();
@@ -519,6 +512,7 @@ Status HybridModelBuilder::MergeNetOutputNode(ComputeGraph &graph) {
        continue;
      }

      GE_CHECK_NOTNULL(dst_in_anchor->GetOwnerNode());
      GE_CHK_STATUS_RET_NOLOG(DoUnlinkDataAnchors(parent_out_anchor, dst_in_anchor));
      GE_CHK_STATUS_RET_NOLOG(DoLinkDataAnchors(src_out_anchor, dst_in_anchor));
    }
@@ -628,8 +622,7 @@ Status HybridModelBuilder::UnfoldSubgraph(ComputeGraph &root_graph,
 Status HybridModelBuilder::BuildOutputMapping(GraphItem &graph_item,
                                              const NodeItem &node_item,
                                              bool is_root_graph) {
  auto output_size = node_item.op_desc->GetAllInputsSize();
  GE_CHECK_LE(output_size, UINT32_MAX);
  auto output_size = node_item.num_inputs;
  graph_item.output_edges_.resize(output_size);

  for (auto &in_data_anchor : node_item.node->GetAllInDataAnchors()) {
@@ -640,14 +633,16 @@ Status HybridModelBuilder::BuildOutputMapping(GraphItem &graph_item,

    auto src_node_item = GetNodeItem(src_node);
    GE_CHECK_NOTNULL(src_node_item);
    auto output_idx = in_data_anchor->GetIdx();
    auto output_offset = src_node_item->output_start + peer_out_anchor->GetIdx();
    GELOGI("Output[%d], node = %s, output_index = %d, output_offset = %d ",
           in_data_anchor->GetIdx(),
           output_idx,
           src_node_item->NodeName().c_str(),
           peer_out_anchor->GetIdx(),
           output_offset);

    graph_item.output_edges_[in_data_anchor->GetIdx()] = {src_node_item, peer_out_anchor->GetIdx()};
    GE_CHECK_LE(output_idx, output_size - 1);
    graph_item.output_edges_[output_idx] = {src_node_item, peer_out_anchor->GetIdx()};
  }

  if (!is_root_graph) {
@@ -820,6 +815,10 @@ Status HybridModelBuilder::InitConstantOps() {
    const NodePtr &var_node = it.second;
    auto op_desc = var_node->GetOpDesc();
    auto v_weights = ModelUtils::GetWeights(op_desc);
    if (v_weights.empty()) {
      GELOGE(INTERNAL_ERROR, "[%s] Constant no not have value", var_node->GetName().c_str());
      return INTERNAL_ERROR;
    }
    auto *ge_tensor = const_cast<GeTensor *>(v_weights[0].get());

    std::unique_ptr<TensorValue> var_tensor;
@@ -884,6 +883,7 @@ Status HybridModelBuilder::InitVariableTensors() {
    GELOGD("Host variable [%s] malloc success.", it.first.c_str());

    std::unique_ptr<TensorValue> tensor(new (std::nothrow) TensorValue(mem_info.host_address, tensor_size));
    GE_CHECK_NOTNULL(tensor);
    hybrid_model_.variable_tensors_.emplace(it.first, std::move(tensor));
  }

@@ -931,7 +931,7 @@ Status HybridModelBuilder::LoadGeModel(ComputeGraph &sub_graph, const GeModelPtr
    GELOGD("Set ge_model for subgraph: [%s], task_size = %d",
           sub_graph.GetName().c_str(),
           ge_model->GetModelTaskDefPtr()->task_size());
    hybrid_model_.known_shape_sub_models_.emplace(sub_graph.GetParentNode(), ge_model);
    hybrid_model_.known_shape_sub_models_.emplace(parent_node, ge_model);
  }

  return SUCCESS;
@@ -1098,7 +1098,7 @@ Status HybridModelBuilder::GetPeerNodeAcrossSubGraphs(const NodePtr &data_node,
  GE_CHECK_NOTNULL(net_output_desc);

  auto out_index = static_cast<uint32_t>(src_wrapped_node_out_anchor->GetIdx());
  GELOGD("src graph = %s, src parent output index = %d", src_graph->GetName().c_str(), out_index);
  GELOGD("src graph = %s, src parent output index = %u", src_graph->GetName().c_str(), out_index);

  // link src to outputs of DataNode
  auto input_size = net_output_desc->GetAllInputsSize();
@@ -1237,7 +1237,8 @@ Status HybridModelBuilder::IdentifyVariableOutputs(NodeItem &node_item) {
    uint32_t parent_index = 0;
    GE_CHK_STATUS_RET_NOLOG(GetParentNodeOutputIndex(*net_output_desc, in_data_anchor->GetIdx(), parent_index));
    GELOGD("Got parent output index = %u", parent_index);
    node_item.ref_outputs.emplace(parent_index, src_node);
    GE_CHECK_LE(parent_index, INT32_MAX);
    node_item.ref_outputs.emplace(static_cast<int>(parent_index), src_node);
  }

  // Data nodes marked with REF_VAR_SRC_VAR_NAME
--- a/ge/hybrid/model/node_item.cc
+++ b/ge/hybrid/model/node_item.cc
@@ -26,9 +26,9 @@
 namespace ge {
 namespace hybrid {
 namespace {
 const char * const kAttrNameOriginalFusionGraph = "_original_fusion_graph";
 const char * const kNodeTypeRetVal = "_RetVal";
 std::set<std::string> kControlOpTypes {
 const char *const kAttrNameOriginalFusionGraph = "_original_fusion_graph";
 const char *const kNodeTypeRetVal = "_RetVal";
 std::set<std::string> kControlOpTypes{
    IF, STATELESSIF, CASE, WHILE, STATELESSWHILE
 };

@@ -54,7 +54,7 @@ Status ParseInputMapping(Node &node, OpDesc &op_desc, FusedSubgraph &fused_subgr
  return SUCCESS;
 }

 Status ParseOutputMapping(OpDescPtr op_desc, FusedSubgraph &fused_subgraph) {
 Status ParseOutputMapping(const OpDescPtr &op_desc, FusedSubgraph &fused_subgraph) {
  uint32_t parent_index = 0;
  if (!AttrUtils::GetInt(op_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index)) {
    GELOGE(FAILED,
@@ -74,7 +74,7 @@ Status ParseFusedSubgraph(NodeItem &node_item) {
  }

  GELOGI("[%s] Start to parse fused subgraph.", node_item.node_name.c_str());
  auto fused_subgraph = std::unique_ptr<FusedSubgraph>(new (std::nothrow)FusedSubgraph());
  auto fused_subgraph = std::unique_ptr<FusedSubgraph>(new(std::nothrow)FusedSubgraph());
  GE_CHECK_NOTNULL(fused_subgraph);

  ComputeGraphPtr fused_graph;
@@ -110,19 +110,39 @@ bool IsControlOp(const std::string &op_type) {
  return kControlOpTypes.count(op_type) > 0;
 }

 NodeItem::NodeItem(NodePtr node): node(std::move(node)) {
 NodeItem::NodeItem(NodePtr node) : node(std::move(node)) {
  this->op_desc = this->node->GetOpDesc().get();
  this->node_id = this->op_desc->GetId();
  this->num_inputs = this->op_desc->GetInputsSize();
  this->num_outputs = this->op_desc->GetOutputsSize();
  this->node_name = this->node->GetName();
  this->node_type = this->node->GetType();
 }

 Status NodeItem::Create(const NodePtr &node, std::unique_ptr<NodeItem> &node_item) {
  GE_CHECK_NOTNULL(node);
  GE_CHECK_NOTNULL(node->GetOpDesc());
  std::unique_ptr<NodeItem> instance(new(std::nothrow)NodeItem(node));
  GE_CHECK_NOTNULL(instance);
  GE_CHK_STATUS_RET(instance->Init(), "Failed to init NodeItem [%s] .", node->GetName().c_str());
  node_item = std::move(instance);
  return SUCCESS;
 }

 Status NodeItem::Init() {
  int32_t unknown_shape_type_val = 0;
  (void) AttrUtils::GetInt(op_desc, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, unknown_shape_type_val);
  shape_inference_type = static_cast<UnknowShapeOpType>(unknown_shape_type_val);
  GE_CHECK_LE(op_desc->GetInputsSize(), INT32_MAX);
  GE_CHECK_LE(op_desc->GetOutputsSize(), INT32_MAX);
  num_inputs = static_cast<int>(op_desc->GetInputsSize());
  num_outputs = static_cast<int>(op_desc->GetOutputsSize());

  if (op_desc->GetAllInputsSize() != op_desc->GetInputsSize()) {
    has_optional_inputs = true;
    for (size_t i = 0; i < op_desc->GetAllInputsSize(); ++i) {
      const auto &input_desc = op_desc->MutableInputDesc(i);
      if (input_desc == nullptr) {
        GELOGD("[%s] Input[%zu] is optional and invalid", NodeName().c_str(), i);
      } else {
        input_desc_indices_.emplace_back(static_cast<uint32_t>(i));
      }
    }
  }

  (void) AttrUtils::GetBool(op_desc, ATTR_NAME_FORCE_UNKNOWN_SHAPE, is_dynamic);
  GELOGD("node name = %s, is_dynamic = %d.", this->node_name.c_str(), is_dynamic);
@@ -132,16 +152,15 @@ Status NodeItem::Init() {
                      node->GetName().c_str());
  }

  GE_CHK_STATUS_RET(ParseFusedSubgraph(*this), "[%s] Failed to parse fused subgraph", node_name.c_str());
  if (is_dynamic) {
    for (int i = 0; i < num_inputs; ++i) {
      const auto &input_desc = op_desc->MutableInputDesc(i);
      const auto &input_desc = MutableInputDesc(i);
      GE_CHECK_NOTNULL(input_desc);
      if (input_desc->MutableShape().IsUnknownShape()) {
        is_input_shape_static.push_back(false);
        is_input_shape_static_.push_back(false);
      } else {
        num_static_input_shapes++;
        is_input_shape_static.push_back(true);
        is_input_shape_static_.push_back(true);
        GELOGD("[%s] The shape of input[%d] is static. shape = [%s]",
               NodeName().c_str(), i, input_desc->MutableShape().ToString().c_str());
      }
@@ -155,6 +174,16 @@ Status NodeItem::Init() {
        break;
      }
    }

    if (IsControlOp() || node_type == PARTITIONEDCALL) {
      shape_inference_type = DEPEND_COMPUTE;
    } else {
      int32_t unknown_shape_type_val = 0;
      (void) AttrUtils::GetInt(op_desc, ::ge::ATTR_NAME_UNKNOWN_SHAPE_TYPE, unknown_shape_type_val);
      shape_inference_type = static_cast<UnknowShapeOpType>(unknown_shape_type_val);
    }

    GE_CHK_STATUS_RET(ParseFusedSubgraph(*this), "[%s] Failed to parse fused subgraph", node_name.c_str());
  }

  return SUCCESS;
@@ -186,7 +215,7 @@ std::string NodeItem::DebugString() const {
  for (auto &items : outputs) {
    ss << ", output[" << index++ << "]: ";
    for (auto &item : items) {
      ss << "(" << item.second->NodeName() << ":" <<item.first << "), ";
      ss << "(" << item.second->NodeName() << ":" << item.first << "), ";
    }
  }

@@ -196,13 +225,60 @@ std::string NodeItem::DebugString() const {
 void NodeItem::SetToDynamic() {
  num_static_input_shapes = 0;
  is_dynamic = true;
  for (size_t i = 0; i < is_input_shape_static.size(); ++i) {
    is_input_shape_static[i] = false;
  for (size_t i = 0; i < is_input_shape_static_.size(); ++i) {
    is_input_shape_static_[i] = false;
  }
  if (kernel_task != nullptr && !kernel_task->IsSupportDynamicShape()) {
    GELOGD("[%s] Dynamic shape is not supported, clear node task.", node_name.c_str());
    kernel_task = nullptr;
  }
 }

 GeTensorDescPtr NodeItem::MutableInputDesc(int index) const {
  if (!has_optional_inputs) {
    return op_desc->MutableInputDesc(static_cast<uint32_t>(index));
  }

  if (index < 0 || index >= num_inputs) {
    GELOGE(PARAM_INVALID,
           "[%s] Invalid input index, num inputs = %d, index = %d",
           node_name.c_str(),
           num_inputs,
           index);
    return nullptr;
  }

  return op_desc->MutableInputDesc(input_desc_indices_[index]);
 }

 Status NodeItem::GetCanonicalInputIndex(uint32_t index, int &canonical_index) const {
  if (!has_optional_inputs) {
    canonical_index = index;
    return SUCCESS;
  }

  auto iter = std::find(input_desc_indices_.begin(), input_desc_indices_.end(), index);
  if (iter == input_desc_indices_.end()) {
    GELOGE(INTERNAL_ERROR, "[%s] Invalid input index: %u", node_name.c_str(), index);
    return INTERNAL_ERROR;
  }

  canonical_index = static_cast<int>(iter - input_desc_indices_.begin());
  GELOGD("[%s] Canonicalize input index from [%u] to [%d]", node_name.c_str(), index, canonical_index);
  return SUCCESS;
 }

 bool NodeItem::IsInputShapeStatic(int index) const {
  if (!is_dynamic) {
    return true;
  }

  if (static_cast<size_t>(index) >= is_input_shape_static_.size()) {
    GELOGE(PARAM_INVALID, "Input index(%d) out of range: [0, %zu)", index, is_input_shape_static_.size());
    return false;
  }

  return is_input_shape_static_[index];
 }
 }  // namespace hybrid
 }  // namespace ge
--- a/ge/hybrid/model/node_item.h
+++ b/ge/hybrid/model/node_item.h
@@ -40,10 +40,8 @@ bool IsControlOp(const std::string &op_type);

 // for caching static information across execution
 struct NodeItem {
  explicit NodeItem(NodePtr node);
  ~NodeItem() = default;

  Status Init();
  static Status Create(const NodePtr &node, std::unique_ptr<NodeItem> &node_item);

  const std::string &NodeName() const {
    return node_name;
@@ -53,6 +51,20 @@ struct NodeItem {
    return node_type;
  }

  OpDescPtr GetOpDesc() const {
    return node->GetOpDesc();
  }

  bool IsInputShapeStatic(int index) const;

  GeTensorDescPtr MutableOutputDesc(int index) const {
    return op_desc->MutableOutputDesc(static_cast<uint32_t>(index));
  }

  GeTensorDescPtr MutableInputDesc(int index) const;

  Status GetCanonicalInputIndex(uint32_t index, int &canonical_index) const;

  bool IsControlOp() const;

  void SetToDynamic();
@@ -61,14 +73,15 @@ struct NodeItem {

  NodePtr node;
  OpDesc *op_desc;
  int node_id;
  int num_inputs;
  int num_outputs;

  int node_id = -1;
  int num_inputs = 0;
  int num_outputs = 0;
  int input_start = -1;
  int output_start = -1;
  bool is_dynamic = false;
  bool has_observer = false;
  bool has_optional_inputs = false;
  bool is_output_shape_static = true;
  UnknowShapeOpType shape_inference_type = DEPEND_IN_SHAPE;
  std::string node_name;
  std::string node_type;
@@ -76,9 +89,8 @@ struct NodeItem {
  std::vector<ge::NodePtr> dependents_for_execution;
  std::set<int> to_const_output_id_list;

  vector<NodeItem *> inputs;
  // src_output_id, dst_anchor_id, dst_node
  vector<vector<pair<uint32_t, NodeItem *>>> outputs;
  vector<vector<pair<int, NodeItem *>>> outputs;

  std::shared_ptr<NodeTask> kernel_task;
  std::unique_ptr<FusedSubgraph> fused_subgraph;
@@ -86,10 +98,14 @@ struct NodeItem {
  std::map<int, ge::NodePtr> ref_outputs;
  std::map<int, int> reuse_inputs;
  std::map<int, int> reuse_outputs;

  std::vector<bool> is_input_shape_static;
  bool is_output_shape_static = true;
  int num_static_input_shapes = 0;

 private:
  explicit NodeItem(NodePtr node);
  Status Init();

  std::vector<bool> is_input_shape_static_;
  std::vector<uint32_t> input_desc_indices_;
 };
 }  // namespace hybrid
 }  // namespace ge
--- a/ge/hybrid/node_executor/aicore/aicore_node_executor.cc
+++ b/ge/hybrid/node_executor/aicore/aicore_node_executor.cc
@@ -157,9 +157,7 @@ Status AiCoreNodeTask::ExecuteAsync(TaskContext &context, std::function<void()>
    return ret;
  }

  auto op_desc = context.GetNodeItem().op_desc;
  GE_CHECK_NOTNULL(op_desc);
  GELOGI("[%s] ExecuteAsync Start.", op_desc->GetName().c_str());
  GELOGI("[%s] ExecuteAsync Start.", context.GetNodeName());
  for (auto it = tasks_.begin(); it != tasks_.end(); ++it) {
    // AtomicAddrClean has 2 tasks
    if (tasks_.size() == 2 && it == tasks_.begin() && !(*(tasks_.rbegin()))->GetClearAtomic()) {
@@ -177,15 +175,13 @@ Status AiCoreNodeTask::ExecuteAsync(TaskContext &context, std::function<void()>
    RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[AiCoreNodeRegisterCallback] End");
  }

  GELOGD("[%s] ExecuteAsync End.", op_desc->GetName().c_str());
  GELOGD("[%s] ExecuteAsync End.", context.GetNodeName());
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[AiCoreNodeTaskExecuteAsync] End");
  return SUCCESS;
 }

 Status AiCoreNodeTask::UpdateArgs(TaskContext &context) {
  auto op_desc = context.GetNodeItem().op_desc;
  GE_CHECK_NOTNULL(op_desc);
  GELOGI("[%s] AiCoreNodeTask UpdateArgs Start.", op_desc->GetName().c_str());
  GELOGI("[%s] AiCoreNodeTask UpdateArgs Start.", context.GetNodeName());
  for (auto it = tasks_.rbegin(); it != tasks_.rend(); ++it) {
    GE_CHK_STATUS_RET_NOLOG((*it)->UpdateArgs(context));
    // AtomicAddrClean has 2 tasks
@@ -193,7 +189,7 @@ Status AiCoreNodeTask::UpdateArgs(TaskContext &context) {
      break;
    }
  }
  GELOGI("[%s] AiCoreNodeTask UpdateArgs End.", op_desc->GetName().c_str());
  GELOGI("[%s] AiCoreNodeTask UpdateArgs End.", context.GetNodeName());
  return SUCCESS;
 }

--- a/ge/hybrid/node_executor/aicpu/aicpu_ext_info.cc
+++ b/ge/hybrid/node_executor/aicpu/aicpu_ext_info.cc
@@ -37,7 +37,10 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
  ext_info_.reset(new(std::nothrow)uint8_t[ext_info_len_]);
  GE_CHECK_NOTNULL(ext_info_);

  (void) memcpy_s(ext_info_.get(), ext_info_len_, ext_info.c_str(), ext_info.size());
  if (memcpy_s(ext_info_.get(), ext_info_len_, ext_info.c_str(), ext_info.size()) != EOK) {
    GELOGE(FAILED, "[%s] Failed to coy ext info", node_name_.c_str());
    return FAILED;
  }

  input_shape_and_type_.clear();
  output_shape_and_type_.clear();
@@ -94,7 +97,7 @@ Status AicpuExtInfoHandler::ParseExtInputShape(AicpuExtInfo *aicpu_ext_info) {
  auto need_len = input_num_ * sizeof(AicpuShapeAndType);
  GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, PARAM_INVALID,
                         "Node[%s] parse ext input shape failed as infoLen must be "
                         "input_num[%zu]*sizeof(ShapeAndType)[%zu] but %u.",
                         "input_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
                         node_name_.c_str(), input_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen);

  auto input = reinterpret_cast<AicpuShapeAndType *>(aicpu_ext_info->infoMsg);
@@ -115,7 +118,7 @@ Status AicpuExtInfoHandler::ParseExtOutputShape(AicpuExtInfo *aicpu_ext_info) {
  auto need_len = output_num_ * sizeof(AicpuShapeAndType);
  GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, PARAM_INVALID,
                         "Node[%s] parse ext output shape failed as infoLen must be "
                         "output_num[%zu]*sizeof(ShapeAndType)[%zu] but %u.",
                         "output_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
                         node_name_.c_str(), output_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen);

  auto output = reinterpret_cast<AicpuShapeAndType *>(aicpu_ext_info->infoMsg);
--- a/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc
+++ b/ge/hybrid/node_executor/aicpu/aicpu_node_executor.cc
@@ -48,7 +48,7 @@ Status AicpuNodeTaskBase::InitExtInfo(const std::string &kernel_ext_info, int64_
      return PARAM_INVALID;
    } else {
      // if no ext info no need copy to device.
      GELOGI("Node[%s] kernel_ext_info is empty, no need copy to device, is_dynamic=%s.",
      GELOGD("Node[%s] kernel_ext_info is empty, no need copy to device, is_dynamic=%s.",
             node_name_.c_str(), node_item_->is_dynamic ? "true" : "false");
      return SUCCESS;
    }
@@ -76,7 +76,7 @@ Status AicpuNodeTaskBase::InitExtInfo(const std::string &kernel_ext_info, int64_

 Status AicpuNodeTaskBase::UpdateOutputShapeFromExtInfo() {
  if (node_item_->num_outputs == 0) {
    GELOGI("Task [%s] output_num is 0, no need update output shape.", node_name_.c_str());
    GELOGD("Task [%s] output_num is 0, no need update output shape.", node_name_.c_str());
    return SUCCESS;
  }
  // copy to host buf
@@ -91,7 +91,7 @@ Status AicpuNodeTaskBase::UpdateOutputShapeFromExtInfo() {
    // not support update data type now, just for param
    DataType data_type;
    aicpu_ext_handle_.GetOutputShapeAndType(i, shape, data_type);
    auto output_desc = node_item_->op_desc->MutableOutputDesc(i);
    auto output_desc = node_item_->MutableOutputDesc(i);
    GE_CHECK_NOTNULL(output_desc);
    GE_CHK_STATUS_RET(UpdateShapeToOutputDesc(shape, i, output_desc),
                      "Update node %s [%d]th output shape failed.",
@@ -104,7 +104,7 @@ Status AicpuNodeTaskBase::UpdateShapeToOutputDesc(const GeShape &shape_new,
                                                  int32_t output_index, GeTensorDescPtr &output_desc) {
  auto shape_old = output_desc->GetShape();
  output_desc->SetShape(shape_new);
  GELOGI("Update node[%s] out[%d] shape from %s to %s.", node_name_.c_str(), output_index,
  GELOGD("Update node[%s] out[%d] shape from %s to %s.", node_name_.c_str(), output_index,
         shape_old.ToString().c_str(), shape_new.ToString().c_str());

  auto origin_shape_old = output_desc->GetOriginShape();
@@ -123,7 +123,7 @@ Status AicpuNodeTaskBase::UpdateShapeToOutputDesc(const GeShape &shape_new,
                    node_name_.c_str(), output_index, origin_format, format, shape_new.ToString().c_str());
  auto origin_shape_new = GeShape(origin_dims_new);
  output_desc->SetOriginShape(origin_shape_new);
  GELOGI("Node[%s] out[%d] originFormat[%d] is not same as format[%d], need update from %s ro %s.",
  GELOGD("Node[%s] out[%d] originFormat[%d] is not same as format[%d], need update from %s ro %s.",
         node_name_.c_str(), output_index, origin_format, format,
         origin_shape_old.ToString().c_str(), origin_shape_new.ToString().c_str());
  return SUCCESS;
@@ -132,12 +132,12 @@ Status AicpuNodeTaskBase::UpdateShapeToOutputDesc(const GeShape &shape_new,
 Status AicpuNodeTaskBase::UpdateExtInfo() {
  GELOGI("Node[%s] update ext info begin, unknown_type=%d.", node_name_.c_str(), unknown_type_);
  if (node_item_->num_inputs == 0 && node_item_->num_outputs == 0) {
    GELOGI("Node[%s] has no input and output, no need update ext info.", node_name_.c_str());
    GELOGD("Node[%s] has no input and output, no need update ext info.", node_name_.c_str());
    return SUCCESS;
  }

  for (auto i = 0; i < node_item_->num_inputs; ++i) {
    auto input_desc = node_item_->op_desc->MutableInputDesc(i);
    auto input_desc = node_item_->MutableInputDesc(i);
    GE_CHECK_NOTNULL(input_desc);
    GE_CHK_STATUS_RET(aicpu_ext_handle_.UpdateInputShapeAndType(i, *input_desc),
                      "Node[%s] input[%d] update input shape failed.",
@@ -146,7 +146,7 @@ Status AicpuNodeTaskBase::UpdateExtInfo() {

  if (unknown_type_ != DEPEND_COMPUTE) {
    for (auto j = 0; j < node_item_->num_outputs; ++j) {
      auto output_desc = node_item_->op_desc->MutableOutputDesc(j);
      auto output_desc = node_item_->MutableOutputDesc(j);
      GE_CHECK_NOTNULL(output_desc);

      GE_CHK_STATUS_RET(aicpu_ext_handle_.UpdateOutputShapeAndType(j, *output_desc),
@@ -162,15 +162,15 @@ Status AicpuNodeTaskBase::UpdateExtInfo() {
                         aicpu_ext_handle_.GetExtInfoLen(),
                         RT_MEMCPY_HOST_TO_DEVICE));

  GELOGI("Node[%s] update ext info end.", node_name_.c_str());
  GELOGD("Node[%s] update ext info end.", node_name_.c_str());
  return SUCCESS;
 }

 Status AicpuNodeTaskBase::UpdateArgs(TaskContext &context) {
  GELOGI("Node[%s] update args begin. is_dynamic=%s, unknown_type=%d",
  GELOGD("Node[%s] update args begin. is_dynamic=%s, unknown_type=%d",
         node_name_.c_str(), node_item_->is_dynamic ? "true" : "false", unknown_type_);
  if (node_item_->num_inputs == 0 && node_item_->num_outputs == 0) {
    GELOGI("Node[%s] has no input and output, no need update args.", node_name_.c_str());
    GELOGD("Node[%s] has no input and output, no need update args.", node_name_.c_str());
    return SUCCESS;
  }

@@ -179,41 +179,41 @@ Status AicpuNodeTaskBase::UpdateArgs(TaskContext &context) {
    // dynamic node need update ext info.
    GE_CHK_STATUS_RET(UpdateExtInfo(), "Node[%s] update ext info failed.", node_name_.c_str());
  }
  GELOGI("Node[%s] update args end.", node_name_.c_str());
  GELOGD("Node[%s] update args end.", node_name_.c_str());
  return SUCCESS;
 }

 Status AicpuNodeTaskBase::ExecuteAsync(TaskContext &context, std::function<void()> done_callback) {
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[AicpuNodeTaskBaseExecuteAsync] Start");
  GELOGI("Node[%s] execute async start. unknown_type=%d.", node_name_.c_str(), unknown_type_);
  GELOGD("Node[%s] execute async start. unknown_type=%d.", node_name_.c_str(), unknown_type_);

  GE_CHK_STATUS_RET(LaunchTask(context));

  auto callback = [=, &context]() {
    GELOGI("Node[%s] callback start.", node_name_.c_str());
    GELOGD("Node[%s] callback start.", node_name_.c_str());
    RECORD_CALLBACK_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[TaskCallback] Start");
    Status callback_ret = TaskCallback(context);
    RECORD_CALLBACK_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[TaskCallback] End");

    GELOGI("Node[%s] task callBack ret = %u.", node_name_.c_str(), callback_ret);
    GELOGD("Node[%s] task callBack ret = %u.", node_name_.c_str(), callback_ret);
    if (done_callback != nullptr) {
      context.SetStatus(callback_ret);
      done_callback();
    }

    GELOGI("Node[%s] callback end.", node_name_.c_str());
    GELOGD("Node[%s] callback end.", node_name_.c_str());
  };

  GE_CHK_STATUS_RET_NOLOG(context.RegisterCallback(callback));

  GELOGI("Node[%s] execute async end.", node_name_.c_str());
  GELOGD("Node[%s] execute async end.", node_name_.c_str());
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[AicpuNodeTaskBaseExecuteAsync] End");
  return SUCCESS;
 }

 Status AicpuTfNodeTask::InitForDependComputeTask() {
  if ((unknown_type_ != DEPEND_COMPUTE) || (node_item_->num_outputs == 0)) {
    GELOGI("Node[%s] type[%s] unknown_type is %d, output num is %d.",
    GELOGD("Node[%s] type[%s] unknown_type is %d, output num is %d.",
           node_name_.c_str(), node_item_->node_type.c_str(), unknown_type_, node_item_->num_outputs);
    return SUCCESS;
  }
@@ -438,7 +438,7 @@ Status AicpuTfNodeTask::PrepareCopyInputs(const TaskContext &context,

  for (auto i = 0; i < node_item_->num_outputs; ++i) {
    const auto &summary = output_summary_host_[i];
    GELOGI("Node[%s] out[%d] summary, shape data=0x%lx, shape data size=%lu, raw data=0x%lx, raw data size=%lu.",
    GELOGD("Node[%s] out[%d] summary, shape data=0x%lx, shape data size=%lu, raw data=0x%lx, raw data size=%lu.",
           node_name_.c_str(), i,
           summary.shape_data_ptr, summary.shape_data_size,
           summary.raw_data_ptr, summary.raw_data_size);
@@ -499,7 +499,7 @@ Status AicpuTfNodeTask::UpdateShapeByHbmBuffer(TaskContext &context,
                         node_name_.c_str(), node_item_->num_outputs, out_shape_hbm.size());
  for (auto i = 0; i < node_item_->num_outputs; ++i) {
    const auto &result_summary = output_summary_host_[i];
    auto output_desc = node_item_->op_desc->MutableOutputDesc(i);
    auto output_desc = node_item_->MutableOutputDesc(i);
    std::vector<int64_t> shape_dims;
    if (result_summary.shape_data_size > 0) {
      const auto &shape_hbm = out_shape_hbm[i];
@@ -507,7 +507,7 @@ Status AicpuTfNodeTask::UpdateShapeByHbmBuffer(TaskContext &context,
                             "Node[%s] [%d]th output shape data size is %lu is not divided by int64_t.",
                             node_name_.c_str(), i, result_summary.shape_data_size);
      uint32_t dim_num = result_summary.shape_data_size / sizeof(int64_t);
      GELOGI("Node[%s] [%d]th output dim num=%u.", node_name_.c_str(), i, dim_num);
      GELOGD("Node[%s] [%d]th output dim num=%u.", node_name_.c_str(), i, dim_num);
      std::unique_ptr<int64_t[]> shape_addr(new(std::nothrow) int64_t[dim_num]());
      GE_CHECK_NOTNULL(shape_addr);
      GE_CHK_RT_RET(rtMemcpy(shape_addr.get(), result_summary.shape_data_size,
@@ -525,7 +525,7 @@ Status AicpuTfNodeTask::UpdateShapeByHbmBuffer(TaskContext &context,
 }

 Status AicpuTfNodeTask::UpdateShapeAndDataByResultSummary(TaskContext &context) {
  GELOGI("Node[%s] update shape and data by result summary begin.", node_name_.c_str());
  GELOGD("Node[%s] update shape and data by result summary begin.", node_name_.c_str());

  std::vector<std::unique_ptr<TensorBuffer>> out_shape_hbm;
  GE_CHK_STATUS_RET(ReadResultSummaryAndPrepareMemory(context, out_shape_hbm),
@@ -545,7 +545,7 @@ Status AicpuTfNodeTask::UpdateShapeAndDataByResultSummary(TaskContext &context)
                    "Node[%s] update shape by hbm buffer failed.",
                    node_name_.c_str());

  GELOGI("Node[%s] update shape and data by result summary end.", node_name_.c_str());
  GELOGD("Node[%s] update shape and data by result summary end.", node_name_.c_str());
  return SUCCESS;
 }

@@ -574,7 +574,7 @@ Status AicpuTfNodeTask::UpdateIoAddr(TaskContext &context) {
    }
  } else {
    // unknown type 4 use result summary update ioaddr.
    GELOGI("Node[%s] is depend compute node, use result summary as out addr.", node_name_.c_str());
    GELOGD("Node[%s] is depend compute node, use result summary as out addr.", node_name_.c_str());
    GE_CHK_BOOL_RET_STATUS(output_summary_.size() == static_cast<std::size_t>(node_item_->num_outputs),
                           INTERNAL_ERROR,
                           "Node[%s] has %d output but %zu output summary.",
@@ -599,17 +599,17 @@ Status AicpuTfNodeTask::UpdateIoAddr(TaskContext &context) {
 }

 Status AicpuTfNodeTask::LaunchTask(TaskContext &context) {
  GELOGI("Node[%s] launch task start, unknown_type=%d.", node_name_.c_str(), unknown_type_);
  GELOGD("Node[%s] launch task start, unknown_type=%d.", node_name_.c_str(), unknown_type_);
  uint32_t flag = RT_KERNEL_DEFAULT;
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[AicpuTfNodertKernelLaunchEx] Start");
  GE_CHK_RT_RET(rtKernelLaunchEx(kernel_buf_->GetData(), kernel_buf_->GetSize(), flag, context.GetStream()));
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[AicpuTfNodertKernelLaunchEx] End");
  GELOGI("Node[%s] launch end.", node_name_.c_str());
  GELOGD("Node[%s] launch end.", node_name_.c_str());
  return SUCCESS;
 }

 Status AicpuTfNodeTask::TaskCallback(TaskContext &context) {
  GELOGI("Node[%s] task callback start. is_dynamic=%s, unknown_type=%d.",
  GELOGD("Node[%s] task callback start. is_dynamic=%s, unknown_type=%d.",
         node_name_.c_str(), node_item_->is_dynamic ? "true" : "false", unknown_type_);
  Status callback_ret = SUCCESS;
  if (node_item_->is_dynamic) {
@@ -621,13 +621,13 @@ Status AicpuTfNodeTask::TaskCallback(TaskContext &context) {
      callback_ret = UpdateShapeAndDataByResultSummary(context);
    }
  }
  GELOGI("Node[%s] task callback end.", node_name_.c_str());
  GELOGD("Node[%s] task callback end.", node_name_.c_str());
  return callback_ret;
 }

 Status AicpuNodeTask::Init(const HybridModel &model) {
  auto node_name = node_name_;
  GELOGI("Node[%s] init start.", node_name.c_str());
  GELOGD("Node[%s] init start.", node_name.c_str());

  GE_CHK_BOOL_RET_STATUS(unknown_type_ != DEPEND_COMPUTE, FAILED,
                         "Node[%s] unknown type[%d] is depend compute, it's not supported now.",
@@ -640,13 +640,12 @@ Status AicpuNodeTask::Init(const HybridModel &model) {
  args_size_ = kernel_def.args_size();

  const std::string &so_name = kernel_def.so_name();
  const OpDescPtr op_desc = MakeShared<OpDesc>(*(node_item_->op_desc));
  const OpDescPtr op_desc = node_item_->GetOpDesc();
  const auto &context = kernel_def.context();
  auto kernel_type = static_cast<cce::ccKernelType>(context.kernel_type());
  if (kernel_type == cce::ccKernelType::CUST_AI_CPU) {
    GE_CHK_STATUS_RET(ModelManager::GetInstance()->LoadCustAicpuSo(op_desc, so_name), "load cust aicpu so failed.");
    GE_CHK_STATUS_RET(ModelManager::GetInstance()->LaunchCustAicpuSo(), "Launch cust aicpu so failed.");

  }

  GE_CHK_BOOL_RET_STATUS(args.size() == args_size_, FAILED,
@@ -698,7 +697,7 @@ Status AicpuNodeTask::Init(const HybridModel &model) {
    aicpu_param_head->extInfoAddr = reinterpret_cast<uintptr_t>(ext_info_addr_dev_->GetData());
  }

  GELOGI("Node[%s] init end.", node_name.c_str());
  GELOGD("Node[%s] init end.", node_name.c_str());
  return SUCCESS;
 }

@@ -733,14 +732,14 @@ Status AicpuNodeTask::UpdateIoAddr(TaskContext &context) {
 }

 Status AicpuNodeTask::LaunchTask(TaskContext &context) {
  GELOGI("Node[%s] launch task start. unknown_type=%d.", node_name_.c_str(), unknown_type_);
  GELOGD("Node[%s] launch task start. unknown_type=%d.", node_name_.c_str(), unknown_type_);
  const auto &so_name = task_def_.kernel().so_name();
  const auto &kernel_name = task_def_.kernel().kernel_name();
  const auto &kcontext = task_def_.kernel().context();
  auto kernel_type = static_cast<cce::ccKernelType>(kcontext.kernel_type());
  uint32_t flag = RT_KERNEL_DEFAULT;
  if (kernel_type == cce::ccKernelType::CUST_AI_CPU) {
    flag |= RT_KERNEL_CUSTOM_AICPU;
    flag |= static_cast<uint32_t>(RT_KERNEL_CUSTOM_AICPU);
  }
  auto rt_ret = rtCpuKernelLaunchWithFlag(reinterpret_cast<const void *>(so_name.c_str()),
                                          reinterpret_cast<const void *>(kernel_name.c_str()),
@@ -748,12 +747,12 @@ Status AicpuNodeTask::LaunchTask(TaskContext &context) {
                                          args_.get(), args_size_,
                                          nullptr, context.GetStream(), flag);
  GE_CHK_RT_RET(rt_ret);
  GELOGI("Node[%s] launch task end.", node_name_.c_str());
  GELOGD("Node[%s] launch task end.", node_name_.c_str());
  return SUCCESS;
 }

 Status AicpuNodeTask::TaskCallback(TaskContext &context) {
  GELOGI("Node[%s] task callback start, is_dynamic = %s, unknown_type=%d.",
  GELOGD("Node[%s] task callback start, is_dynamic = %s, unknown_type=%d.",
         node_name_.c_str(), node_item_->is_dynamic ? "true" : "false", unknown_type_);
  Status callback_ret = SUCCESS;

@@ -762,10 +761,10 @@ Status AicpuNodeTask::TaskCallback(TaskContext &context) {
    // check result
    callback_ret = UpdateOutputShapeFromExtInfo();
  } else {
    GELOGI("Node[%s] unknown shape type is %d no need update output shape.",
    GELOGD("Node[%s] unknown shape type is %d no need update output shape.",
           node_name_.c_str(), unknown_type_);
  }
  GELOGI("Node[%s] task callback end.", node_name_.c_str());
  GELOGD("Node[%s] task callback end.", node_name_.c_str());
  return callback_ret;
 }

@@ -781,7 +780,7 @@ Status AiCpuNodeExecutor::LoadTask(const HybridModel &model,
                                   const NodePtr &node,
                                   std::shared_ptr<NodeTask> &task) const {
  GE_CHECK_NOTNULL(node);
  GELOGI("Node[%s] load task start.", node->GetName().c_str());
  GELOGD("Node[%s] load task start.", node->GetName().c_str());
  auto node_item = model.GetNodeItem(node);
  GE_CHECK_NOTNULL(node_item);
  auto task_defs = model.GetTaskDefs(node);
@@ -815,7 +814,7 @@ Status AiCpuNodeExecutor::LoadTask(const HybridModel &model,
  GE_CHK_STATUS_RET(aicpu_task->Init(model), "Node[%s] task init failed.", node->GetName().c_str());

  task = std::move(aicpu_task);
  GELOGI("Node[%s] load task end.", node->GetName().c_str());
  GELOGD("Node[%s] load task end.", node->GetName().c_str());
  return SUCCESS;
 }
 }  // namespace hybrid
--- a/ge/hybrid/node_executor/compiledsubgraph/known_node_executor.cc
+++ b/ge/hybrid/node_executor/compiledsubgraph/known_node_executor.cc
@@ -31,14 +31,12 @@ REGISTER_NODE_EXECUTOR_BUILDER(NodeExecutorManager::ExecutorType::COMPILED_SUBGR

 Status KnownNodeTask::   ExecuteAsync(TaskContext &context, std::function<void()> done_callback) {
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodeTaskExecuteAsync] Start");
  GELOGI("[%s] KnownNodeTask::ExecuteAsync in.", context.GetNodeName());
  if (davinci_model_->GetTaskList().size() == 0) {
    GELOGW("KnownNodeExecutor::ExecuteAsync davinci moel has no taskinfo.");
  GELOGD("[%s] KnownNodeTask::ExecuteAsync in.", context.GetNodeName());
  if (davinci_model_->GetTaskList().empty()) {
    GELOGW("KnownNodeExecutor::ExecuteAsync davinci model has no taskinfo.");

    // todo if data is connected to netoutput, forward address ? copy data?
    if (context.NumInputs() == context.NumOutputs()){
      GELOGW("[%s] KnownNodeExecutor::ExecuteAsync davinci moel has no taskinfo.",
             context.GetNodeName());
      for (int i = 0; i < context.NumInputs(); ++i) {
        auto tensor = context.MutableInput(i);
        GE_CHECK_NOTNULL(tensor);
@@ -54,24 +52,22 @@ Status KnownNodeTask::   ExecuteAsync(TaskContext &context, std::function<void()
  }

  rtError_t rt_ret;
  GELOGI("rtModelExecute start.");
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodertModelExecute] Start");
  rt_ret = rtModelExecute(davinci_model_->GetRtModelHandle(), context.GetStream(), 0);
  GE_IF_BOOL_EXEC(rt_ret != RT_ERROR_NONE,
                  GELOGE(rt_ret, "rtModelExecute error, ret: hybrid_model_executorOx%X", rt_ret); return FAILED;);
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodertModelExecute] End");
  GELOGI("rtModelExecute end");

  GE_CHK_STATUS_RET_NOLOG(context.RegisterCallback(done_callback));
  GELOGI("[%s] KnownNodeTask::ExecuteAsync success.", context.GetNodeName());
  GELOGD("[%s] KnownNodeTask::ExecuteAsync success.", context.GetNodeName());
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodeTaskExecuteAsync] End");
  return SUCCESS;
 }

 Status KnownNodeTask::UpdateArgs(TaskContext &context) {
  GELOGI("[%s] KnownNodeExecutor::UpdateArgs in.", context.GetNodeName());
  if (davinci_model_->GetTaskList().size() == 0) {
    GELOGW("KnownNodeExecutor::UpdateArgs davinci moel has no taskinfo.");
  GELOGD("[%s] KnownNodeExecutor::UpdateArgs in.", context.GetNodeName());
  if (davinci_model_->GetTaskList().empty()) {
    GELOGW("KnownNodeExecutor::UpdateArgs davinci model has no taskinfo.");
    return SUCCESS;
  }

@@ -91,7 +87,7 @@ Status KnownNodeTask::UpdateArgs(TaskContext &context) {

  GE_CHK_STATUS_RET(davinci_model_->UpdateKnownNodeArgs(inputs, outputs),
                    "known node task update known node args failed.");
  GELOGI("[%s] KnownNodeExecutor::UpdateArgs success, task_size = %d:", context.GetNodeName(),
  GELOGD("[%s] KnownNodeExecutor::UpdateArgs success, task_size = %zu", context.GetNodeName(),
         davinci_model_->GetTaskList().size());
  return SUCCESS;
 }
@@ -123,7 +119,7 @@ Status KnownNodeTask::Init(TaskContext &context) {
    davinci_model_->SetKnownNodeAddrNotChanged(addr_not_changed);
    // update mem base
    davinci_model_->UpdateMemBase(static_cast<uint8_t *>(buffer));
    GELOGI("KnownNodeTask::Init mem base is %p, size %u.",
    GELOGI("KnownNodeTask::Init mem base is %p, size %lu.",
           davinci_model_->GetRuntimeParam().mem_base, davinci_model_->GetRuntimeParam().mem_size);
  }
  if (!load_flag_) {
@@ -138,7 +134,7 @@ Status KnownNodeTask::Init(TaskContext &context) {
 }

 Status KnownNodeExecutor::PrepareTask(NodeTask &task, TaskContext &context) const {
  GELOGI("[%s] KnownNodeExecutor::PrepareTask in.", context.GetNodeName());
  GELOGD("[%s] KnownNodeExecutor::PrepareTask in.", context.GetNodeName());
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodeExecutorPrepareTask] Start");
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodeExecutorTaskInit] Start");
  GE_CHK_STATUS_RET(task.Init(context), "known node init davinci model failed.");
@@ -148,7 +144,7 @@ Status KnownNodeExecutor::PrepareTask(NodeTask &task, TaskContext &context) cons
  GE_CHK_STATUS_RET(task.UpdateArgs(context), "known node task update args failed.");
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodeExecutorUpdateArgs] End");
  RECORD_EXECUTION_EVENT(context.GetExecutionContext(), context.GetNodeName(), "[KnownNodeExecutorPrepareTask] End");
  GELOGI("[%s] KnownNodeExecutor::PrepareTask success.", context.GetNodeName());
  GELOGD("[%s] KnownNodeExecutor::PrepareTask success.", context.GetNodeName());
  return SUCCESS;
 }

@@ -167,7 +163,7 @@ Status KnownNodeExecutor::LoadTask(const HybridModel &model, const NodePtr &node
  davinci_model->SetKnownNode(true);
  // set model id as root node's node id
  davinci_model->SetId(node->GetOpDesc()->GetId());
  GELOGD("KnownNodeExecutor::LoadTask node id %u.", node->GetOpDesc()->GetId());
  GELOGD("KnownNodeExecutor::LoadTask node id %ld.", node->GetOpDesc()->GetId());

  GE_CHK_STATUS_RET(davinci_model->Assign(ge_model), "KnownNodeExecutor::LoadTask davincimodel assign failed.");

--- a/ge/hybrid/node_executor/controlop/control_op_executor.cc
+++ b/ge/hybrid/node_executor/controlop/control_op_executor.cc
@@ -119,6 +119,7 @@ Status IfOpNodeTask::Init(const NodePtr &node, const HybridModel &model) {

 Status IfOpNodeTask::DoExecuteAsync(TaskContext &task_context, const std::function<void()> &done_callback) const {
  auto cond_tensor_desc = task_context.MutableInputDesc(kIfCondIndex);
  GE_CHECK_NOTNULL(cond_tensor_desc);
  auto data_type = cond_tensor_desc->GetDataType();
  const auto &shape = cond_tensor_desc->MutableShape();
  bool cond_val = false;
@@ -362,14 +363,16 @@ Status WhileOpNodeTask::MoveOutputs2Inputs(TaskContext &task_context) {
    *input_tensor = *output_tensor;
    output_tensor->Destroy();

    auto input_tensor_desc = task_context.MutableInputDesc(i);
    GE_CHECK_NOTNULL(input_tensor_desc);
    auto output_tensor_desc = task_context.MutableOutputDesc(i);
    GE_CHECK_NOTNULL(output_tensor_desc);
    GELOGD("[%s] To update input shape[%d] by output shape. from [%s] to [%s]",
           task_context.GetNodeName(),
           i,
           task_context.MutableInputDesc(i)->GetShape().ToString().c_str(),
           input_tensor_desc->GetShape().ToString().c_str(),
           output_tensor_desc->GetShape().ToString().c_str());
    *task_context.MutableInputDesc(i) = *output_tensor_desc;
    *input_tensor_desc = *output_tensor_desc;
  }

  return SUCCESS;
--- a/ge/hybrid/node_executor/hccl/hccl_node_executor.cc
+++ b/ge/hybrid/node_executor/hccl/hccl_node_executor.cc
@@ -67,14 +67,16 @@ Status HcclNodeTask::ExecuteAsync(TaskContext &context, std::function<void()> do
  }

  const NodeItem &node_item = context.GetNodeItem();
  const OpDescPtr op_desc = MakeShared<OpDesc>(*(node_item.op_desc));
  const OpDescPtr op_desc = node_item.GetOpDesc();
  GE_CHECK_NOTNULL(op_desc);

  HcomOpertion op_info;
  op_info.hcclType = op_desc->GetType();
  op_info.inputPtr = inputs.empty() ? nullptr : inputs[0];
  op_info.outputPtr = outputs.empty() ? nullptr : outputs[0];
  ge::DataType src_data_type = op_desc->GetInputDescPtr(0)->GetDataType();
  auto input_desc = node_item.MutableInputDesc(0);
  GE_CHECK_NOTNULL(input_desc);
  ge::DataType src_data_type = input_desc->GetDataType();
  auto iter = kConstOpHcclDataType.find(static_cast<int64_t>(src_data_type));
  if (iter == kConstOpHcclDataType.end()) {
    GELOGE(PARAM_INVALID, "kConstOpHcclDataType find failed.");
@@ -83,7 +85,7 @@ Status HcclNodeTask::ExecuteAsync(TaskContext &context, std::function<void()> do
  op_info.dataType = iter->second;
  HcclReduceOp op_type = HCCL_REDUCE_SUM;
  if (op_desc->GetType() == HCOMALLREDUCE || op_desc->GetType() == HCOMREDUCESCATTER ||
      op_desc->GetType() == HVDCALLBACKALLREDUCE) {
      op_desc->GetType() == HVDCALLBACKALLREDUCE || op_desc->GetType() == HCOMREDUCE) {
    GE_CHK_STATUS_RET(HcomOmeUtil::GetHcclOperationType(op_desc, op_type), "GetHcclOperationType failed");
    op_info.opType = op_type;
  }
@@ -128,8 +130,9 @@ Status RdmaNodeTask::UpdateArgs(TaskContext &context) { return SUCCESS; }
 Status RdmaNodeTask::Init(TaskContext &context) {
  GELOGI("[%s] RdmaNodeTask::Init in.", context.GetNodeName());
  const NodeItem &node_item = context.GetNodeItem();
  GE_CHECK_NOTNULL(node_item.op_desc);
  auto remote_idx = node_item.op_desc->GetInputIndexByName("remote");
  auto op_desc = node_item.GetOpDesc();
  GE_CHECK_NOTNULL(op_desc);
  auto remote_idx = op_desc->GetInputIndexByName("remote");
  auto in_data_anchor = node_item.node->GetInDataAnchor(remote_idx);
  GE_CHECK_NOTNULL(in_data_anchor);
  auto out_data_anchor = in_data_anchor->GetPeerOutAnchor();
@@ -141,7 +144,7 @@ Status RdmaNodeTask::Init(TaskContext &context) {
  if (node_item.node->GetType() == HCOMREMOTEREAD) {
    local_index_ = 0;
  } else {
    local_index_ = node_item.op_desc->GetInputIndexByName("local");
    local_index_ = op_desc->GetInputIndexByName("local");
  }
  return SUCCESS;
 }
--- a/ge/hybrid/node_executor/host_cpu/host_cpu_node_executor.cc
+++ b/ge/hybrid/node_executor/host_cpu/host_cpu_node_executor.cc
@@ -47,7 +47,9 @@ Status CpuKernelNodeTask::Execute(TaskContext &context) {

  std::vector<ConstGeTensorPtr> inputs;
  for (int32_t i = 0; i < context.NumInputs(); ++i) {
    const auto &input_desc = op_desc->GetInputDesc(i);
    auto input_desc_ptr = context.GetInputDesc(i);
    GE_CHECK_NOTNULL(input_desc_ptr);
    const auto &input_desc = *input_desc_ptr;
    GE_CHECK_NOTNULL(context.GetInput(i));
    auto in_tensor = MakeShared<GeTensor>(input_desc,
                                          reinterpret_cast<const uint8_t *>(context.GetInput(i)->GetData()),
@@ -56,8 +58,7 @@ Status CpuKernelNodeTask::Execute(TaskContext &context) {
    in_tensor->MutableTensorDesc().SetDataType(input_desc.GetDataType());
    in_tensor->MutableTensorDesc().SetShape(input_desc.GetShape());
    inputs.emplace_back(in_tensor);
    GELOGI("node:%s allocate input %zu, addr=%p, size=%lld", op_desc->GetName().c_str(), i,
           reinterpret_cast<const uint8_t *>(in_tensor->GetData().data()), in_tensor->GetData().size());
    GELOGI("node:%s allocate input %d, size=%zu", op_desc->GetName().c_str(), i, in_tensor->GetData().size());
  }

  std::vector<GeTensorPtr> outputs;
@@ -78,8 +79,7 @@ Status CpuKernelNodeTask::Execute(TaskContext &context) {
    out_tensor->MutableTensorDesc().SetDataType(output_desc.GetDataType());
    out_tensor->MutableTensorDesc().SetShape(output_desc.GetShape());
    outputs.emplace_back(out_tensor);
    GELOGI("node:%s allocate output %d, addr=%p, size=%zu", op_desc->GetName().c_str(), i,
           reinterpret_cast<const uint8_t *>(out_tensor->GetData().data()), out_tensor->GetData().size());
    GELOGI("node:%s allocate output %d, size=%zu", op_desc->GetName().c_str(), i, out_tensor->GetData().size());
  }

  return HostCpuEngine::GetInstance().Run(node_, inputs, outputs);
--- a/ge/hybrid/node_executor/node_executor.cc
+++ b/ge/hybrid/node_executor/node_executor.cc
@@ -16,6 +16,7 @@

 #include "hybrid/node_executor/node_executor.h"
 #include "framework/common/debug/log.h"
 #include "common/math/math_util.h"
 #include "graph/utils/node_utils.h"
 #include "init/gelib.h"
 #include "graph/utils/tensor_utils.h"
@@ -138,8 +139,9 @@ Status NodeExecutorManager::CalcOpRunningParam(Node &node) const {
    GELOGD("[%s] Skipping CalcOpRunningParam for PartitionedCall.", node.GetName().c_str());
    return SUCCESS;
  }
  for (size_t i = 0; i < node.GetOpDesc()->GetOutputsSize(); ++i) {
  for (size_t i = 0; i < op_desc->GetOutputsSize(); ++i) {
    GeTensorDescPtr output_tensor = op_desc->MutableOutputDesc(static_cast<uint32_t>(i));
    GE_CHECK_NOTNULL(output_tensor);
    TensorUtils::SetSize(*(output_tensor.get()), 0);
  }

@@ -155,6 +157,10 @@ Status NodeExecutorManager::CalcOpRunningParam(Node &node) const {
      int64_t output_mem_size = 0;
      GE_CHK_STATUS_RET(TensorUtils::CalcTensorMemSize(output_shape, format, data_type, output_mem_size),
                        "hccl calc tensor mem size failed.");
      GE_CHK_STATUS_RET(CheckInt64AddOverflow(output_mem_size, MEMORY_ALIGN_RATIO * MEMORY_ALIGN_SIZE - 1),
                        "[%s] Invalid output mem size: %ld",
                        node.GetName().c_str(),
                        output_mem_size);
      output_mem_size = ((output_mem_size +
                          MEMORY_ALIGN_RATIO * MEMORY_ALIGN_SIZE - 1) / MEMORY_ALIGN_SIZE) * MEMORY_ALIGN_SIZE;
      TensorUtils::SetSize(output_tensor, output_mem_size);
--- a/ge/hybrid/node_executor/task_context.cc
+++ b/ge/hybrid/node_executor/task_context.cc
@@ -253,7 +253,7 @@ Status TaskContext::AllocateOutput(int index,

 Status TaskContext::AllocateOutputs(AllocationAttr *attr) {
  for (int i = 0; i < node_item_->num_outputs; ++i) {
    const auto &output_desc = node_item_->op_desc->MutableOutputDesc(i);
    const auto &output_desc = node_item_->MutableOutputDesc(i);
    GE_CHECK_NOTNULL(output_desc);
    uint32_t mem_type = 0;
    (void)AttrUtils::GetInt(output_desc, ATTR_OUTPUT_MEMORY_TYPE, mem_type);
@@ -349,7 +349,7 @@ Status TaskContext::PropagateOutputs() {
      auto dst_input_idx = dst_input_index_and_node.first;
      auto dst_node_item = dst_input_index_and_node.second;
      auto input_offset = dst_node_item->input_start + dst_input_idx;
      GELOGI(
      GELOGD(
          "Propagate output of node %s, output index = %d, dst node = %s, "
          "dst_input_index = %d, dst_input_offset = %d.",
          node_item_->NodeName().c_str(),
@@ -394,20 +394,20 @@ void TaskContext::ReleaseInput(int index) {
  }
 }

 ConstGeTensorDescPtr TaskContext::GetOutputDesc(int index) {
  return node_item_->op_desc->MutableOutputDesc(static_cast<uint32_t>(index));
 ConstGeTensorDescPtr TaskContext::GetOutputDesc(int index) const {
  return node_item_->MutableOutputDesc(static_cast<uint32_t>(index));
 }

 ConstGeTensorDescPtr TaskContext::GetInputDesc(int index) {
  return node_item_->op_desc->MutableInputDesc(static_cast<uint32_t>(index));
 ConstGeTensorDescPtr TaskContext::GetInputDesc(int index) const {
  return node_item_->MutableInputDesc(index);
 }

 GeTensorDescPtr TaskContext::MutableInputDesc(int index) {
  return node_item_->op_desc->MutableInputDesc(static_cast<uint32_t>(index));
 GeTensorDescPtr TaskContext::MutableInputDesc(int index) const {
  return node_item_->MutableInputDesc(index);
 }

 GeTensorDescPtr TaskContext::MutableOutputDesc(int index) {
  return node_item_->op_desc->MutableOutputDesc(static_cast<uint32_t>(index));
 GeTensorDescPtr TaskContext::MutableOutputDesc(int index) const {
  return node_item_->MutableOutputDesc(static_cast<uint32_t>(index));
 }

 bool TaskContext::IsForceInferShape() const {
--- a/ge/hybrid/node_executor/task_context.h
+++ b/ge/hybrid/node_executor/task_context.h
@@ -46,10 +46,10 @@ class TaskContext {
  const NodeItem &GetNodeItem() const;
  const char *GetNodeName() const;
  TensorValue *MutableInput(int index);
  ConstGeTensorDescPtr GetInputDesc(int index);
  ConstGeTensorDescPtr GetOutputDesc(int index);
  GeTensorDescPtr MutableInputDesc(int index);
  GeTensorDescPtr MutableOutputDesc(int index);
  ConstGeTensorDescPtr GetInputDesc(int index) const;
  ConstGeTensorDescPtr GetOutputDesc(int index) const;
  GeTensorDescPtr MutableInputDesc(int index) const;
  GeTensorDescPtr MutableOutputDesc(int index) const;
  void ReleaseInput(int index);
  const TensorValue *GetInput(int index) const;
  const TensorValue *GetOutput(int index) const;
--- a/inc/external/ge/ge_api_error_codes.h
+++ b/inc/external/ge/ge_api_error_codes.h
@@ -97,13 +97,10 @@ GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_PARAM_INVALID, "Parameter invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_NOT_INIT, "GE executor not initialized yet.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID, "Model file path invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_ID_INVALID, "Model id invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID, "Model key path invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION, "Model does not support encryption.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "Data size of model invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID, "Model addr invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID, "Queue id of model invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED, "The model loaded repeatedly.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID, "Model partition num invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID, "Dynamic input addr invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID, "Dynamic input size invalid.");
 GE_ERRORNO_EXTERNAL(ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID, "Dynamic batch size invalid.");
--- a/inc/external/ge/ge_error_codes.h
+++ b/inc/external/ge/ge_error_codes.h
@@ -26,13 +26,10 @@ static const uint32_t ACL_ERROR_GE_PARAM_INVALID = 145000;
 static const uint32_t ACL_ERROR_GE_EXEC_NOT_INIT = 145001;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID = 145002;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_ID_INVALID = 145003;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_KEY_PATH_INVALID = 145004;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_NOT_SUPPORT_ENCRYPTION = 145005;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID = 145006;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_ADDR_INVALID = 145007;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_QUEUE_ID_INVALID = 145008;
 static const uint32_t ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED = 145009;
 static const uint32_t ACL_ERROR_GE_EXEC_MODEL_PARTITION_NUM_INVALID = 145010;
 static const uint32_t ACL_ERROR_GE_DYNAMIC_INPUT_ADDR_INVALID = 145011;
 static const uint32_t ACL_ERROR_GE_DYNAMIC_INPUT_LENGTH_INVALID = 145012;
 static const uint32_t ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID = 145013;
--- a/inc/framework/common/types.h
+++ b/inc/framework/common/types.h
@@ -431,6 +431,7 @@ REGISTER_OPTYPE_DECLARE(HCOMBROADCAST, "HcomBroadcast");
 REGISTER_OPTYPE_DECLARE(HCOMALLGATHER, "HcomAllGather");
 REGISTER_OPTYPE_DECLARE(HCOMALLREDUCE, "HcomAllReduce");
 REGISTER_OPTYPE_DECLARE(HCOMREDUCESCATTER, "HcomReduceScatter");
 REGISTER_OPTYPE_DECLARE(HCOMREDUCE, "HcomReduce");
 REGISTER_OPTYPE_DECLARE(HCOMSEND, "HcomSend");
 REGISTER_OPTYPE_DECLARE(HCOMRECEIVE, "HcomReceive");
 REGISTER_OPTYPE_DECLARE(HCOMREMOTEREAD, "HcomRemoteRead");
--- a/tests/ut/common/graph/testcase/ge_graph/ge_format_refiner_unittest.cc
+++ b/tests/ut/common/graph/testcase/ge_graph/ge_format_refiner_unittest.cc
@@ -453,7 +453,7 @@ ut::GraphBuilder BuildGraph8() {
  return builder;
 }
 }  // namespace

 /*
 TEST_F(UtestFormatRefiner, data_format) {
  auto builder = BuildGraph8();
  auto graph = builder.GetGraph();
@@ -468,7 +468,7 @@ TEST_F(UtestFormatRefiner, data_format) {
  EXPECT_EQ(relu->GetOpDesc()->GetOutputDesc(0).GetOriginFormat(), FORMAT_NCHW);
  //FormatRefiner::SetInferOrigineFormatFlag(true);
 }

 */
 TEST_F(UtestFormatRefiner, constant_fail) {
  //FormatRefiner::SetInferOrigineFormatFlag(true);
  auto builder = BuildGraph6();
--- a/tests/ut/ge/CMakeLists.txt
+++ b/tests/ut/ge/CMakeLists.txt
@@ -104,8 +104,6 @@ set(COMMON_SRC_FILES
    "${GE_CODE_DIR}/metadef/graph/operator.cc"
    "${GE_CODE_DIR}/metadef/graph/operator_factory.cc"
    "${GE_CODE_DIR}/metadef/graph/operator_factory_impl.cc"
    #"${GE_CODE_DIR}/metadef/graph/operator_reg.cc"
    #"${GE_CODE_DIR}/metadef/graph/range_vistor.cc"
    "${GE_CODE_DIR}/metadef/graph/ge_tensor.cc"
    "${GE_CODE_DIR}/metadef/graph/ref_relation.cc"
    "${GE_CODE_DIR}/metadef/graph/tensor.cc"
@@ -123,7 +121,6 @@ set(COMMON_SRC_FILES
    "${GE_CODE_DIR}/metadef/ops/op_imp.cpp"
    "${GE_CODE_DIR}/metadef/register/register.cpp"
    "${GE_CODE_DIR}/metadef/register/op_kernel_registry.cpp"
    #"${GE_CODE_DIR}/tests/depends/cce/src/op_kernel_registry.cpp"
    "${GE_CODE_DIR}/metadef/register/auto_mapping_util.cpp"
    "${GE_CODE_DIR}/metadef/register/tensor_assign.cpp"
    "${GE_CODE_DIR}/metadef/register/register_format_transfer.cc"
@@ -308,6 +305,7 @@ set(COMMON_SRC_FILES
    "${GE_CODE_DIR}/metadef/register/op_tiling.cpp"
    "${GE_CODE_DIR}/metadef/graph/utils/tuning_utils.cc"
    "${GE_CODE_DIR}/metadef/register/op_tiling_registry.cpp"
    "${GE_CODE_DIR}/ge/ge_local_engine/engine/host_cpu_engine.cc"
 )

 set(COMMON_FORMAT_SRC_FILES
@@ -655,7 +653,7 @@ set(MULTI_PARTS_TEST_FILES
    "common/format_transfer_nchw_fractalz_unittest.cc"
    "common/format_transfer_hwcn_fractalz_unittest.cc"
    "common/format_transfer_nhwc_fractalz_unittest.cc"
    "common/format_transfer_fractal_nz_unittest.cc"
    #"common/format_transfer_fractal_nz_unittest.cc"
    "common/format_transfer_fractal_zz_unittest.cc"
    "common/format_transfer_nhwc_5d_unittest.cc"
    "common/format_transfer_5d_nchw_unittest.cc"
@@ -851,7 +849,7 @@ target_compile_definitions(ut_libge_multiparts_utest PRIVATE

 target_link_libraries(ut_libge_multiparts_utest
    $<BUILD_INTERFACE:intf_pub>
    ge_build_common ge_load_common ge_execute_common ge_optimize_common ge_partition_common ge_pass_common ge_prepare_common ge_single_op ge_ut_common gtest gtest_main ascend_protobuf ${COMMON_SHARED_LIBRARIES} json -lrt -ldl 
    ge_build_common ge_load_common ge_execute_common ge_optimize_common ge_partition_common ge_prepare_common ge_single_op ge_ut_common gtest gtest_main ascend_protobuf ${COMMON_SHARED_LIBRARIES} json -lrt -ldl 
 )

 # libge_others_utest
@@ -864,7 +862,7 @@ add_executable(ut_libge_others_utest
 )
 target_link_libraries(ut_libge_others_utest
    $<BUILD_INTERFACE:intf_pub>
    ge_build_common ge_load_common ge_execute_common ge_optimize_common ge_partition_common ge_pass_common ge_prepare_common ge_single_op ge_ut_common gtest gtest_main ascend_protobuf ${COMMON_SHARED_LIBRARIES} json -lrt -ldl
    ge_load_common ge_execute_common ge_ut_common gtest gtest_main ascend_protobuf ${COMMON_SHARED_LIBRARIES} json -lrt -ldl
 )

 # libge_kernel_utest
@@ -876,7 +874,7 @@ add_executable(ut_libge_kernel_utest
 )
 target_link_libraries(ut_libge_kernel_utest
    $<BUILD_INTERFACE:intf_pub>
    ge_build_common ge_load_common ge_execute_common ge_optimize_common ge_partition_common ge_pass_common ge_prepare_common ge_single_op ge_ut_common gtest gtest_main ascend_protobuf ${COMMON_SHARED_LIBRARIES} json -lrt -ldl
    ge_load_common ge_ut_common gtest gtest_main ascend_protobuf ${COMMON_SHARED_LIBRARIES} json -lrt -ldl
 )

 # libge_distinct_load_utest
@@ -895,7 +893,7 @@ target_compile_definitions(ut_libge_distinct_load_utest PRIVATE
 target_link_libraries(ut_libge_distinct_load_utest 
 	${COMMON_SHARED_LIBRARIES}
 	$<BUILD_INTERFACE:intf_pub>
        ge_execute_common ge_ut_common_format ge_pass_common ge_load_common
        ge_execute_common ge_ut_common_format ge_load_common
        ge_single_op   ge_prepare_common
        ge_optimize_common  ge_build_common ge_partition_common ge_ut_common
        gtest gtest_main ascend_protobuf json c_sec -lrt -ldl -lpthread
--- a/tests/ut/ge/common/datatype_transfer_unittest.cc
+++ b/tests/ut/ge/common/datatype_transfer_unittest.cc
@@ -368,6 +368,7 @@ TEST_F(UtestDataTypeTransfer, invalid_src_data_type) {
  EXPECT_EQ(transfer.TransDataType(args, result), UNSUPPORTED);
 }

 /*
 TEST_F(UtestDataTypeTransfer, src_shape_empry) {
  uint8_t data[1 * 4 * 4 * 1] = {0};

@@ -377,6 +378,7 @@ TEST_F(UtestDataTypeTransfer, src_shape_empry) {
  TransResult result;
  EXPECT_EQ(transfer.TransDataType(args, result), PARAM_INVALID);
 }
 */

 TEST_F(UtestDataTypeTransfer, unsupprot_trans) {
  bool data[1 * 4 * 4 * 1] = {0};
--- a/tests/ut/ge/common/format_transfer_fractal_nz_unittest.cc
+++ b/tests/ut/ge/common/format_transfer_fractal_nz_unittest.cc
@@ -35,6 +35,7 @@ class UtestFormatTransferNdFractNz : public testing::Test {
  void TearDown() {}
 };

 /*
 TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_1) {
  uint8_t data[1] = {
      176,
@@ -52,8 +53,8 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_1) {
  FormatTransferFractalNz transfer;
  TransArgs args{reinterpret_cast<uint8_t *>(data), FORMAT_ND, FORMAT_FRACTAL_NZ, {1}, {1, 1, 32, 32}, DT_UINT8};
  TransResult result;
  EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  //EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  //EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  for (int i = 0; i < sizeof(ret) / sizeof(ret[0]); ++i) {
    EXPECT_EQ((reinterpret_cast<uint8_t *>(result.data.get()))[i], ret[i]);
  }
@@ -68,6 +69,7 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_1) {
  }
 }


 TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_2) {
  uint8_t data[32] = {
      194, 182, 243, 9,   141, 3,  25,  168, 123, 253, 25, 2,  76, 207, 206, 214,
@@ -120,8 +122,8 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_2) {
  FormatTransferFractalNz transfer;
  TransArgs args{reinterpret_cast<uint8_t *>(data), FORMAT_ND, FORMAT_FRACTAL_NZ, {32}, {1, 1, 32, 32}, DT_UINT8};
  TransResult result;
  EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  //EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  //EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  for (int i = 0; i < sizeof(ret) / sizeof(ret[0]); ++i) {
    EXPECT_EQ((reinterpret_cast<uint8_t *>(result.data.get()))[i], ret[i]);
  }
@@ -136,6 +138,7 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_2) {
  }
 }


 TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_3) {
  uint8_t data[33] = {
      173, 126, 65,  202, 177, 161, 81, 98, 165, 98,  206, 162, 209, 58,  160, 171, 124,
@@ -229,8 +232,8 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_3) {
  FormatTransferFractalNz transfer;
  TransArgs args{reinterpret_cast<uint8_t *>(data), FORMAT_ND, FORMAT_FRACTAL_NZ, {33}, {2, 1, 32, 32}, DT_UINT8};
  TransResult result;
  EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  //EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  //EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  for (int i = 0; i < sizeof(ret) / sizeof(ret[0]); ++i) {
    EXPECT_EQ((reinterpret_cast<uint8_t *>(result.data.get()))[i], ret[i]);
  }
@@ -244,6 +247,8 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape1_uint8_3) {
    EXPECT_EQ((reinterpret_cast<uint8_t *>(result2.data.get()))[i], data[i]);
  }
 }
 */


 TEST_F(UtestFormatTransferNdFractNz, nd_shape2_uint8_1) {
  uint8_t data[32 * 32] = {
@@ -344,8 +349,8 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape2_uint8_1) {
  FormatTransferFractalNz transfer;
  TransArgs args{reinterpret_cast<uint8_t *>(data), FORMAT_ND, FORMAT_FRACTAL_NZ, {32, 32}, {1, 1, 32, 32}, DT_UINT8};
  TransResult result;
  EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  //EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
  //EXPECT_EQ(result.length, sizeof(ret) / sizeof(ret[0]));
  for (int i = 0; i < sizeof(ret) / sizeof(ret[0]); ++i) {
    EXPECT_EQ((reinterpret_cast<uint8_t *>(result.data.get()))[i], ret[i]);
  }
--- a/tests/ut/ge/common/format_transfer_fractal_zz_unittest.cc
+++ b/tests/ut/ge/common/format_transfer_fractal_zz_unittest.cc
@@ -35,6 +35,7 @@ class UtestFormatTransferNdFractZz : public testing::Test {
  void TearDown() {}
 };


 TEST_F(UtestFormatTransferNdFractZz, nd_shape1_uint8_1) {
  uint8_t data[1] = {
      176,
--- a/tests/ut/ge/common/format_transfer_nhwc_5d_unittest.cc
+++ b/tests/ut/ge/common/format_transfer_nhwc_5d_unittest.cc
@@ -694,6 +694,7 @@ TEST_F(UtestFormatTransferNhwc5d, invalid_src_shape1) {
  EXPECT_EQ(transfer.TransFormat(args, result), PARAM_INVALID);
 }

 /*
 TEST_F(UtestFormatTransferNhwc5d, invalid_src_shape2) {
  uint16_t data[1 * 4 * 4 * 1] = {0};
  TransArgs args{
@@ -706,6 +707,7 @@ TEST_F(UtestFormatTransferNhwc5d, invalid_src_shape2) {
      transfer.TransShape(args.src_format, args.src_shape, args.src_data_type, args.dst_format, args.dst_shape);
  EXPECT_EQ(status, PARAM_INVALID);
 }
 */

 TEST_F(UtestFormatTransferNhwc5d, invalid_src_format) {
  uint16_t data[1 * 4 * 4 * 1] = {0};
--- a/tests/ut/ge/common/format_transfer_transpose_unittest.cc
+++ b/tests/ut/ge/common/format_transfer_transpose_unittest.cc
@@ -54,6 +54,7 @@ TEST_F(UtestFormatTranspose, no_trans) {
  }
 }

 /*
 TEST_F(UtestFormatTranspose, param_invalid) {
  uint8_t data[5] = {1, 2, 3, 4, 5};

@@ -83,6 +84,7 @@ TEST_F(UtestFormatTranspose, param_invalid) {
                                    DT_UINT8, std::vector<int64_t>({3, 1, 0, 2}), result),
            SUCCESS);
 }
 */

 TEST_F(UtestFormatTranspose, transpose_with_shape_check_2d) {
  uint8_t data[4] = {1, 2, 3, 4};
@@ -4653,4 +4655,4 @@ TEST_F(UtestFormatTranspose, chwn_to_hwcn2) {
  }
 }
 }  // namespace formats
 }  // namespace ge
 }  // namespace ge
--- a/tests/ut/ge/graph/ge_executor_unittest.cc
+++ b/tests/ut/ge/graph/ge_executor_unittest.cc
@@ -67,6 +67,7 @@ class UtestGeExecutor : public testing::Test {
  }
 };

 /*
 TEST_F(UtestGeExecutor, fail_UnloadModel_model_manager_stop_unload_error) {
  uint32_t model_id = 1;
  ge::GeExecutor ge_executor;
@@ -85,3 +86,4 @@ TEST_F(UtestGeExecutor, fail_CommandHandle_model_manager_HandleCommand_error) {
  ge::Status ret = ge_executor.CommandHandle(cmd);
  EXPECT_EQ(ge::PARAM_INVALID, ret);
 }
 */
--- a/tests/ut/ge/graph/load/data_dumper_unittest.cc
+++ b/tests/ut/ge/graph/load/data_dumper_unittest.cc
@@ -38,7 +38,7 @@ std::vector<void *> stub_get_output_addrs(const RuntimeParam &model_param, Const
  res.emplace_back(reinterpret_cast<void *>(23333));
  return res;
 }

 /*
 TEST_F(UtestDataDumper, LoadDumpInfo_no_output_addrs_fail) {
  RuntimeParam rts_param;
  DataDumper data_dumper(rts_param);
@@ -52,6 +52,7 @@ TEST_F(UtestDataDumper, LoadDumpInfo_no_output_addrs_fail) {
  Status ret = data_dumper.LoadDumpInfo();
  EXPECT_EQ(ret, SUCCESS);
 }
 */

 TEST_F(UtestDataDumper, UnloadDumpInfo_success) {
  RuntimeParam rts_param;
--- a/tests/ut/ge/graph/passes/base_pass_unittest.cc
+++ b/tests/ut/ge/graph/passes/base_pass_unittest.cc
@@ -414,7 +414,7 @@ TEST_F(UTESTGraphPassesBasePass, re_pass_and_del) {
  EXPECT_EQ(ge_pass.Run(names_to_pass), SUCCESS);
  EXPECT_EQ(test_pass.GetIterNodes().size(), 7);
 }

 /*
 TEST_F(UTESTGraphPassesBasePass, dead_loop) {
  NamesToPass names_to_pass;
  auto test_pass = UtestTestPass(true);
@@ -428,7 +428,7 @@ TEST_F(UTESTGraphPassesBasePass, dead_loop) {
  EXPECT_EQ(ge_pass.Run(names_to_pass), SUCCESS);
  EXPECT_EQ(test_pass.GetRunTimes(), 1007);
 }

 */
 TEST_F(UTESTGraphPassesBasePass, while_loop) {
  NamesToPass names_to_pass;
  auto test_pass = UtestTestPass(true);
--- a/tests/ut/ge/graph/passes/folding_kernel/empty_kernel_unittest.cc
+++ b/tests/ut/ge/graph/passes/folding_kernel/empty_kernel_unittest.cc
@@ -144,6 +144,7 @@ TEST_F(UtestEmptyKernel, ShapeDataTypeCheclFail) {
  }
 }

 /*
 TEST_F(UtestEmptyKernel, DtypeCheckFail) {
  vector<int64_t> dims_vec_0 = {5};
  vector<int64_t> data_vec_0 = {2, 1, 4, 1, 2};
@@ -164,6 +165,7 @@ TEST_F(UtestEmptyKernel, DtypeCheckFail) {
    EXPECT_EQ(ge::PARAM_INVALID, status);
  }
 }
 */

 TEST_F(UtestEmptyKernel, SizeCheckFail) {
  vector<int64_t> dims_vec_0 = {-1};
--- a/tests/ut/ge/graph/passes/folding_kernel/fill_kernel_unittest.cc
+++ b/tests/ut/ge/graph/passes/folding_kernel/fill_kernel_unittest.cc
@@ -238,6 +238,7 @@ TEST_F(UtestGraphPassesFoldingKernelFillKernel, FillDimsHaveNegativeNumber) {
  EXPECT_EQ(PARAM_INVALID, status);
 }

 /*
 TEST_F(UtestGraphPassesFoldingKernelFillKernel, FillDataTypeNotSupport) {
  ge::OpDescPtr op_dims = std::make_shared<ge::OpDesc>();
  vector<int64_t> dims_vec = {2};
@@ -263,6 +264,7 @@ TEST_F(UtestGraphPassesFoldingKernelFillKernel, FillDataTypeNotSupport) {

  EXPECT_EQ(PARAM_INVALID, status);
 }
 */

 TEST_F(UtestGraphPassesFoldingKernelFillKernel, FillDimsTypeNotSupport) {
  ge::OpDescPtr op_dims = std::make_shared<ge::OpDesc>();
--- a/tests/ut/ge/graph/passes/folding_kernel/permute_kernel_unittest.cc
+++ b/tests/ut/ge/graph/passes/folding_kernel/permute_kernel_unittest.cc
@@ -49,6 +49,7 @@ class UtestGraphPassesFoldingKernelPermuteKernel : public testing::Test {
  void TearDown() {}
 };

 /*
 TEST_F(UtestGraphPassesFoldingKernelPermuteKernel, ComputeNchwToNhwc) {
  const std::string ATTR_ORDER = "order";
  const std::string ATTR_PERM = "perm";
@@ -75,6 +76,7 @@ TEST_F(UtestGraphPassesFoldingKernelPermuteKernel, ComputeNchwToNhwc) {
  EXPECT_EQ(ge::SUCCESS, status);
 }


 TEST_F(UtestGraphPassesFoldingKernelPermuteKernel, ComputeTransaxises) {
  const std::string ATTR_ORDER = "order";
  const std::string ATTR_PERM = "perm";
@@ -234,3 +236,4 @@ TEST_F(UtestGraphPassesFoldingKernelPermuteKernel, ComputeParamInvalid3) {
  ge::Status status = kernel->Compute(op_desc_ptr, input2, outputs);
  EXPECT_EQ(ge::PARAM_INVALID, status);
 }
 */
--- a/tests/ut/ge/graph/passes/net_output_pass_unittest.cc
+++ b/tests/ut/ge/graph/passes/net_output_pass_unittest.cc
@@ -765,6 +765,7 @@ TEST_F(UtestGraphPassesNetOutputPass, check_order_and_const_flag_success) {
  EXPECT_EQ(retval_node2, nullptr);
 }

 /*
 TEST_F(UtestGraphPassesNetOutputPass, out_node_check_fail) {
  ge::ComputeGraphPtr compute_graph = build_graph();

@@ -789,6 +790,7 @@ TEST_F(UtestGraphPassesNetOutputPass, out_node_check_fail) {
  net_out_node = compute_graph->FindNode(NODE_NAME_NET_OUTPUT);
  EXPECT_EQ(net_out_node, nullptr);
 }
 */

 TEST_F(UtestGraphPassesNetOutputPass, retval_node_check_fail) {
  ge::ComputeGraphPtr compute_graph = build_graph();
--- a/tests/ut/ge/graph/passes/pass_manager_unittest.cc
+++ b/tests/ut/ge/graph/passes/pass_manager_unittest.cc
@@ -79,7 +79,7 @@ TEST_F(UtestGraphPassesPassManagerPass, all_pass_success) {
  Status status = manager.Run(graph);
  EXPECT_EQ(SUCCESS, status);
 }

 /*
 TEST_F(UtestGraphPassesPassManagerPass, graph_pass_success) {
  ComputeGraphPtr graph = CreatePadGraph();
  SuccessGraphPass pass;
@@ -87,7 +87,7 @@ TEST_F(UtestGraphPassesPassManagerPass, graph_pass_success) {
  Status status = PassManager::Run(graph, passes);
  EXPECT_EQ(SUCCESS, status);
 }

 */
 TEST_F(UtestGraphPassesPassManagerPass, graph_pass_not_changed) {
  ComputeGraphPtr graph = CreatePadGraph();
  NotChangedGraphPass pass;
@@ -95,7 +95,7 @@ TEST_F(UtestGraphPassesPassManagerPass, graph_pass_not_changed) {
  Status status = PassManager::Run(graph, passes);
  EXPECT_EQ(NOT_CHANGED, status);
 }

 /*
 TEST_F(UtestGraphPassesPassManagerPass, graph_pass_error) {
  ComputeGraphPtr graph = CreatePadGraph();
  ErrorGraphPass pass;
@@ -103,3 +103,4 @@ TEST_F(UtestGraphPassesPassManagerPass, graph_pass_error) {
  Status status = PassManager::Run(graph, passes);
  EXPECT_EQ(FAILED, status);
 }
 */
--- a/tests/ut/ge/graph/passes/reshape_remove_pass_unittest.cc
+++ b/tests/ut/ge/graph/passes/reshape_remove_pass_unittest.cc
@@ -110,6 +110,7 @@ ut::GraphBuilder Graph3Builder() {

 }  // namespace

 /*
 TEST_F(UtestReshapeRemovePass, reshape_remove_with_const) {
  auto builder = Graph1Builder();
  auto graph = builder.GetGraph();
@@ -131,6 +132,7 @@ TEST_F(UtestReshapeRemovePass, reshape_remove_with_const) {
  EXPECT_EQ(var1->GetOutDataNodes().at(0)->GetName(), "transdata1");
 }


 TEST_F(UtestReshapeRemovePass, reshape_remove_without_const_two_reshape) {
  auto builder = Graph2Builder();
  auto graph = builder.GetGraph();
@@ -179,4 +181,5 @@ TEST_F(UtestReshapeRemovePass, reshape_remove_without_const) {
  EXPECT_NE(const1, nullptr);
  EXPECT_EQ(const1->GetOutNodes().size(), 1);
 }
 */
 }  // namespace ge
--- a/tests/ut/ge/graph/passes/resource_pair_control_pass_unittest.cc
+++ b/tests/ut/ge/graph/passes/resource_pair_control_pass_unittest.cc
@@ -54,7 +54,7 @@ ut::GraphBuilder Graph1Builder() {
  return builder;
 }
 }

 /*
 TEST_F(UtestResourcePairControlPass, resource_pair_control) {
  auto builder = Graph1Builder();
  auto graph = builder.GetGraph();
@@ -91,4 +91,5 @@ TEST_F(UtestResourcePairControlPass, resource_pair_control) {
  EXPECT_EQ(stackpop2->GetInNodes().size(), 1);
  EXPECT_EQ(stackpop2->GetInControlNodes().size(), 0);
 }
 */
 }
--- a/tests/ut/ge/graph/passes/trans_op_breadth_fusion_pass_unittest.cc
+++ b/tests/ut/ge/graph/passes/trans_op_breadth_fusion_pass_unittest.cc
@@ -62,7 +62,7 @@ class NodeBuilder {

  ge::OpDescPtr op_desc_;
 };

 /*
 TEST_F(UtestGraphPassesTransOpBreadthFusionPass, test_simple_trans_data) {
  ///             ___ NodeTrans4DToFZ_1 __ NodeFZ
  ///            |
@@ -312,6 +312,7 @@ TEST_F(UtestGraphPassesTransOpBreadthFusionPass, test_control_anchor) {
  EXPECT_TRUE(cast_node_2->GetOutControlNodes().empty());
  EXPECT_TRUE(cast_node_1->GetOutDataNodes().empty());
 }
 */

 TEST_F(UtestGraphPassesTransOpBreadthFusionPass, test_reshape_op_failed) {
  ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
--- a/tests/ut/ge/single_op/single_op_manager_unittest.cc
+++ b/tests/ut/ge/single_op/single_op_manager_unittest.cc
@@ -42,7 +42,7 @@ TEST_F(UtestSingleOpManager, test_get_resource) {
  auto &instance = SingleOpManager::GetInstance();
  ASSERT_NE(instance.GetResource(0x01, stream), nullptr);
 }

 /*
 TEST_F(UtestSingleOpManager, test_get_op_from_model) {
  auto stream = (rtStream_t)0x1;
  uintptr_t resource_id = 0x1;
@@ -57,7 +57,7 @@ TEST_F(UtestSingleOpManager, test_get_op_from_model) {
  ASSERT_EQ(instance.GetOpFromModel("model", model_data, stream, &single_op), FAILED);
  ASSERT_EQ(instance.GetResource(resource_id, stream)->GetOperator(model_data.model_data), nullptr);
 }

 */
 TEST_F(UtestSingleOpManager, test_relesase_resource) {
  auto stream = (rtStream_t)0x99;
  auto &instance = SingleOpManager::GetInstance();
@@ -67,6 +67,7 @@ TEST_F(UtestSingleOpManager, test_relesase_resource) {
  ASSERT_EQ(instance.ReleaseResource(stream), SUCCESS);
 }

 /*
 TEST_F(UtestSingleOpManager, test_get_op_from_model_with_null_stream) {
  void *stream = nullptr;

@@ -92,3 +93,4 @@ TEST_F(UtestSingleOpManager, get_resource_failed) {

  ASSERT_EQ(instance.GetOpFromModel("model", model_data, stream, &single_op), FAILED);
 }
 */
--- a/tests/ut/ge/single_op/single_op_model_unittest.cc
+++ b/tests/ut/ge/single_op/single_op_model_unittest.cc
@@ -40,6 +40,7 @@ class UtestSingleOpModel : public testing::Test {
  void TearDown() {}
 };

 /*
 TEST_F(UtestSingleOpModel, test_init_model) {
  string model_data_str = "123456789";
  SingleOpModel model("model", model_data_str.c_str(), model_data_str.size());
@@ -68,6 +69,7 @@ TEST_F(UtestSingleOpModel, test_parse_input_node) {
  op_desc->SetOutputOffset(offsets);
  ASSERT_EQ(model.ParseInputNode(op_desc), PARAM_INVALID);
 }
 */

 TEST_F(UtestSingleOpModel, test_parse_output_node) {
  string model_data_str = "123456789";
@@ -103,7 +105,7 @@ TEST_F(UtestSingleOpModel, test_set_inputs_and_outputs) {

  ASSERT_EQ(model.SetInputsAndOutputs(single_op), SUCCESS);
 }

 /*
 TEST_F(UtestSingleOpModel, test_build_kernel_task) {
  string model_data_str = "123456789";
  SingleOpModel model("model", model_data_str.c_str(), model_data_str.size());
@@ -145,6 +147,7 @@ TEST_F(UtestSingleOpModel, test_init) {
  SingleOpModel op_model("model", model_data_str.c_str(), model_data_str.size());
  ASSERT_EQ(op_model.Init(), FAILED);
 }
 */

 TEST_F(UtestSingleOpModel, test_parse_arg_table) {
  string model_data_str = "123456789";