Merge branch 'master' of gitee.com:mindspore/graphengine into master

ge/common/dump/dump_properties.cc

@@ -441,16 +441,10 @@ Status DumpProperties::SetDumpDebugOptions() {
   if (enable_dump_debug_ == kEnableFlag) {
     std::string dump_debug_mode;
     if (GetContext().GetOption(OPTION_EXEC_DUMP_DEBUG_MODE, dump_debug_mode) == GRAPH_SUCCESS) {
-      GELOGD("Get dump debug mode %s successfully", dump_debug_mode.c_str());
+      GELOGD("Get ge.exec.dumpDebugMode %s successfully", dump_debug_mode.c_str());
     } else {
-      REPORT_INPUT_ERROR("E10001", std::vector<std::string>({"parameter", "value", "reason"}),
-                         std::vector<std::string>({
-                         "ge.exec.dumpDebugMode",
-                         dump_debug_mode,
-                         "ge.exec.dumpDebugMode is not set."}));
-      GELOGE(PARAM_INVALID, "[Check][dump_debug_mode] failed. Dump debug mode is not set.");
-
-      return PARAM_INVALID;
+      GELOGW("ge.exec.dumpDebugMode is not set.");
+      return SUCCESS;
     }
 
     if (dump_debug_mode == OP_DEBUG_AICORE) {

ge/common/formats/format_transfers/format_transfer_c1hwncoc0_hwcn.cc

@@ -123,6 +123,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, int size
           auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                     ? total_size - dst_offset
                                     : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_fractal_nz.cc

@@ -59,7 +59,7 @@ bool CheckShape(Format format, const ShapeVector &shape) {
       return CheckShapeValid(shape, kDimSize4D);
     default:
       std::string error = "Trans format between " + FmtToStr(TypeUtils::FormatToSerialString(format)) +
-          " and FORMAT_FRACTAL_NZ is not supported.";
+                          " and FORMAT_FRACTAL_NZ is not supported.";
       GE_ERRORLOG_AND_ERRORMSG(ACL_ERROR_GE_FORMAT_INVALID, error.c_str());
       return false;
   }
@@ -185,6 +185,7 @@ Status TransFormatFromNdToFracNz(const TransArgs &args, TransResult &result, con
         auto src_offset = (src_h_head + w1_idx * w0) * size;
         auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN) ?
                               dst_size - dst_offset : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+        GE_CHECK_GE(protected_size, 0);
         auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                             static_cast<size_t>(size * w0));
         if (ret != EOK) {
@@ -202,6 +203,7 @@ Status TransFormatFromNdToFracNz(const TransArgs &args, TransResult &result, con
         auto src_offset = (src_h_head + src_w_idx) * size;
         auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN) ?
                               dst_size - dst_offset : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+        GE_CHECK_GE(protected_size, 0);
         auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                             static_cast<size_t>(size));
         if (ret != EOK) {
@@ -267,6 +269,7 @@ Status TransFormatFromFracNzToNd(const TransArgs &args, TransResult &result, con
         auto dst_offset = (dst_h_head + w1_idx * w0) * size;
         auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN) ?
                               dst_size - dst_offset : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+        GE_CHECK_GE(protected_size, 0);
         ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                        static_cast<size_t>(size * w0));
         if (ret != EOK) {
@@ -285,6 +288,7 @@ Status TransFormatFromFracNzToNd(const TransArgs &args, TransResult &result, con
         auto dst_offset = (dst_h_head + dst_w_idx) * size;
         auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN) ?
                               dst_size - dst_offset : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+        GE_CHECK_GE(protected_size, 0);
         ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                        static_cast<size_t>(size));
         if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_fractal_z.cc

@@ -226,6 +226,7 @@ Status TransFormatFromNchwToFz(const TransArgs &args, TransResult &result) {
           auto protected_size = dst_size - offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                     ? dst_size - offset
                                     : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           errno_t ret = EOK;
           if (need_pad_zero) {
             ret = memset_s(dst.get() + offset, static_cast<size_t>(protected_size), 0, static_cast<size_t>(size));
@@ -390,6 +391,7 @@ Status TransFormatHwcnToFz(const TransArgs &args, TransResult &result) {
             auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                       ? dst_size - dst_offset
                                       : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+            GE_CHECK_GE(protected_size, 0);
             auto pad_zero = ((c1i * c0 + c0i) >= c) || (n1n0i >= n);
             errno_t ret = EOK;
             if (pad_zero) {
@@ -474,6 +476,7 @@ Status TransFormatNhwcToFz(const TransArgs &args, TransResult &result) {
             auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                       ? dst_size - dst_offset
                                       : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+            GE_CHECK_GE(protected_size, 0);
             auto pad_zero = ((c1i * c0 + c0i) >= c) || (n1n0i >= n);
             errno_t ret = EOK;
             if (pad_zero) {

ge/common/formats/format_transfers/format_transfer_fractal_zz.cc

@@ -193,6 +193,7 @@ Status TransFormatFromNdToFracZz(const TransArgs &args, TransResult &result, con
           auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                   ? dst_size - dst_offset
                                   : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size * w0));
           if (ret != EOK) {
@@ -213,6 +214,7 @@ Status TransFormatFromNdToFracZz(const TransArgs &args, TransResult &result, con
           auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                   ? dst_size - dst_offset
                                   : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {
@@ -284,6 +286,7 @@ Status TransFormatFromFracZzToNd(const TransArgs &args, TransResult &result, con
           auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                   ? dst_size - dst_offset
                                   : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size * w0));
           if (ret != EOK) {
@@ -304,6 +307,7 @@ Status TransFormatFromFracZzToNd(const TransArgs &args, TransResult &result, con
           auto protected_size = dst_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                   ? dst_size - dst_offset
                                   : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_fracz_hwcn.cc

@@ -128,6 +128,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const in
           auto dst_offset = dst_idx * size;
           auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN) ?
                                 total_size - dst_offset : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_fracz_nchw.cc

@@ -130,6 +130,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const in
           auto dst_offset = dst_idx * size;
           auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN) ?
                                 total_size - dst_offset : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_fracz_nhwc.cc

@@ -128,6 +128,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, int size
           auto dst_offset = dst_idx * size;
           auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN) ?
                                 total_size - dst_offset : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_hwcn_c1hwncoc0.cc

@@ -149,6 +149,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const in
               auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                         ? total_size - dst_offset
                                         : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+              GE_CHECK_GE(protected_size, 0);
               int64_t c_idx = c0_idx + c1_idx * c0;
               int64_t src_idx = h_idx * wcn + w_idx * cn + c_idx * n + n_idx;
               auto src_offset = src_idx * size;

ge/common/formats/format_transfers/format_transfer_nc1hwc0_nchw.cc

@@ -129,6 +129,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const in
           auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                     ? total_size - dst_offset
                                     : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_nc1hwc0_nhwc.cc

@@ -129,6 +129,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const in
           auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                     ? total_size - dst_offset
                                     : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+          GE_CHECK_GE(protected_size, 0);
           auto ret = memcpy_s(dst.get() + dst_offset, static_cast<size_t>(protected_size), args.data + src_offset,
                               static_cast<size_t>(size));
           if (ret != EOK) {

ge/common/formats/format_transfers/format_transfer_nchw_nc1hwc0.cc

@@ -144,6 +144,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const in
             auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                       ? total_size - dst_offset
                                       : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+            GE_CHECK_GE(protected_size, 0);
             int64_t cIdx = c0_idx + c1_idx * c0;
             int64_t srcIdx = n_idx * chw + cIdx * hw + h_idx * w + w_idx;
             auto src_offset = srcIdx * size;

ge/common/formats/format_transfers/format_transfer_nhwc_nc1hwc0.cc

@@ -149,6 +149,7 @@ Status GetDstDataAfterTrans(const TransArgs &args, TransResult &result, const in
             auto protected_size = total_size - dst_offset < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                                       ? total_size - dst_offset
                                       : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+            GE_CHECK_GE(protected_size, 0);
             int64_t c_idx = c0_idx + c1_idx * c0;
             int64_t src_idx = n_idx * hwc + h_idx * wc + w_idx * c + c_idx;
             auto src_offset = src_idx * size;

ge/common/formats/format_transfers/format_transfer_transpose.cc

@@ -171,6 +171,7 @@ Status Transpose(const uint8_t *src, const std::vector<int64_t> &src_shape, Data
     auto protected_size = dst_size - dst_offset_bytes < static_cast<int64_t>(SECUREC_MEM_MAX_LEN)
                               ? dst_size - dst_offset_bytes
                               : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
+    GE_CHECK_GE(protected_size, 0);
     auto ret = memcpy_s(dst.get() + dst_offset_bytes, static_cast<size_t>(protected_size), src + src_offset,
                         static_cast<size_t>(data_size));
     if (ret != EOK) {

ge/common/profiling/ge_profiling.cc

@@ -230,21 +230,15 @@ ge::Status ProfSetStepInfo(uint64_t index_id, uint16_t tag_id, rtStream_t stream
     REPORT_CALL_ERROR("E19999", "Get logic device id failed, ret 0x%X", rt_ret);
     return ge::FAILED;
   }
+  auto &profiling_manager = ge::ProfilingManager::Instance();
+  profiling_manager.SetStepInfoIndex(index_id);
   if (is_first_run && tag_id == kStepStart) {
-    GE_CHK_STATUS_RET_NOLOG(ge::ProfilingManager::Instance().ProfileStepInfo(index_id,
-                                                                             kModelId,
-                                                                             tag_id,
-                                                                             stream,
-                                                                             device_id));
+    GE_CHK_STATUS_RET_NOLOG(profiling_manager.ProfileStepInfo(index_id, kModelId, tag_id, stream, device_id));
     is_first_run = false;
     return ge::SUCCESS;
   }
   if (!is_first_run && tag_id == kStepEnd) {
-    GE_CHK_STATUS_RET_NOLOG(ge::ProfilingManager::Instance().ProfileStepInfo(index_id,
-                                                                             kModelId,
-                                                                             tag_id,
-                                                                             stream,
-                                                                             device_id));
+    GE_CHK_STATUS_RET_NOLOG(profiling_manager.ProfileStepInfo(index_id, kModelId, tag_id, stream, device_id));
     is_first_run = true;
     return ge::SUCCESS;
   }

ge/common/profiling/profiling_manager.cc

@@ -69,6 +69,7 @@ ProfilingManager::ProfilingManager()
     : is_load_profiling_(false), is_execute_profiling_(false), is_training_trace_(false), subscribe_count_(0) {
   prof_cb_.msprofCtrlCallback = nullptr;
   prof_cb_.msprofReporterCallback = nullptr;
+  index_id_ = UINT64_MAX;
 }
 
 ProfilingManager::~ProfilingManager() {}
@@ -604,6 +605,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfFi
   is_load_profiling_ = false;
   is_training_trace_ = false;
   is_execute_profiling_ = false;
+  index_id_ = UINT64_MAX;
 
   // profiling plugin uninit
   PluginUnInit();

ge/common/profiling/profiling_manager.h

@@ -101,6 +101,8 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager {
   void GetOpInputOutputInfo(const OpDescPtr &op, TaskDescInfo &task_desc_info) const;
   void ReportData(const int32_t &device_id, const std::string &data, const std::string &tag_name);
   Status ProfileStepInfo(uint64_t index_id, uint64_t model_id, uint16_t tag_id, rtStream_t stream, int32_t device_id);
+  void SetStepInfoIndex(uint64_t index_id) { index_id_ = index_id; }
+  uint64_t GetStepInfoIndex() { return index_id_; }
  private:
   Status InitFromOptions(const Options &options, MsprofGeOptions &prof_conf);
   Status ParseOptions(const std::string &options);
@@ -127,6 +129,7 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager {
   std::string fp_point_;
   std::string bp_point_;
   uint32_t reporter_max_len_ = 0;
+  uint64_t index_id_;
 };
 }  // namespace ge
 #endif  // GE_COMMON_PROFILING_PROFILING_MANAGER_H_

ge/graph/execute/model_executor.cc

@@ -193,7 +193,7 @@ Status ModelExecutor::PushGraph(const RunArgs &args) {
 
 void ModelExecutor::RunThread() {
   ErrorManager::GetInstance().SetStage(error_message::kModelExecute, error_message::kModelExecute);
-  if (prctl(PR_SET_NAME, ("GE_Run")) != 0) {
+  if (mmSetCurrentThreadName("GE_Run") != EN_OK) {
     GELOGW("Set thread name failed.");
   }
 

ge/graph/load/model_manager/davinci_model.cc

@@ -387,8 +387,8 @@ Status DavinciModel::InitWeightMem(void *dev_ptr, void *weight_ptr, size_t weigh
 
 Status DavinciModel::InitFeatureMapAndP2PMem(void *dev_ptr, size_t mem_size) {
   if (is_feature_map_mem_has_inited_) {
-    REPORT_INNER_ERROR("E19999", "Call InitFeatureMapMem more than once, model_id:%u, check invalid", model_id_);
-    GELOGE(PARAM_INVALID, "[Check][Param] call InitFeatureMapMem more than once, model_id:%u", model_id_);
+    REPORT_INNER_ERROR("E19999", "InitFeatureMapMem is called more than once, model_id:%u, check invalid", model_id_);
+    GELOGE(PARAM_INVALID, "[Check][Param] InitFeatureMapMem is called more than once, model_id:%u", model_id_);
     return PARAM_INVALID;
   }
   is_feature_map_mem_has_inited_ = true;
@@ -456,8 +456,7 @@ Status DavinciModel::InitVariableMem() {
 
 void DavinciModel::InitRuntimeParams() {
   int64_t value = 0;
-  bool ret;
-  ret = ge::AttrUtils::GetInt(ge_model_, ATTR_MODEL_MEMORY_SIZE, value);
+  bool ret = ge::AttrUtils::GetInt(ge_model_, ATTR_MODEL_MEMORY_SIZE, value);
   runtime_param_.mem_size = ret ? (uint64_t)value : 0;
   ret = ge::AttrUtils::GetInt(ge_model_, ATTR_MODEL_WEIGHT_SIZE, value);
   runtime_param_.weight_size = ret ? (uint64_t)value : 0;
@@ -983,7 +982,7 @@ Status DavinciModel::InitDataOp(const ComputeGraphPtr &graph, const NodePtr &nod
   // op_desc Checked by Init: Data, valid.
   auto op_desc = node->GetOpDesc();
   if (node->GetOwnerComputeGraph() != graph) {
-    GELOGI("Skip subgraph Data node: %s.", op_desc->GetName().c_str());
+    GELOGI("Skip Data node: %s in subgraph.", op_desc->GetName().c_str());
     return SUCCESS;
   }
 
@@ -1195,7 +1194,7 @@ Status DavinciModel::InitRealSizeAndShapeInfo(const ComputeGraphPtr &compute_gra
     GELOGD("No need to get size and shape of netoutput in subgraph.");
     return SUCCESS;
   }
-  GELOGD("Start init real size and shape info of %s.", node->GetName().c_str());
+  GELOGD("Start to initialize real size and shape info of %s.", node->GetName().c_str());
   GetAllGearsInfo(node);
   if (is_getnext_sink_dynamic_) {
     GE_IF_BOOL_EXEC(GetGetDynamicDimsNodeInfo(node) != SUCCESS,
@@ -1238,7 +1237,7 @@ void DavinciModel::GetAllGearsInfo(const NodePtr &node) {
       }
       if (!gear_info.empty()) {
         all_gears_info_.emplace_back(gear_info);
-        GELOGD("Init all gears info from %s, gaer info is %s", node->GetName().c_str(),
+        GELOGD("Init all gears info from %s, gear info is %s", node->GetName().c_str(),
                formats::JoinToString(gear_info).c_str());
       }
     }
@@ -1318,7 +1317,7 @@ Status DavinciModel::GetGearAndRealOutSizeInfo(const ComputeGraphPtr &graph, con
 
 Status DavinciModel::GetRealOutputSizeOfCase(const ComputeGraphPtr &graph, size_t input_index,
                                              const NodePtr &case_node) {
-  GELOGD("Start get output size of %s, which is %zu input to netoutput", case_node->GetName().c_str(), input_index);
+  GELOGD("Start to get output size of %s, which is %zu input to netoutput", case_node->GetName().c_str(), input_index);
   const auto &func_desc = case_node->GetOpDesc();
   GE_CHECK_NOTNULL(func_desc);
   std::map<vector<int32_t>, int64_t> gear_and_real_out_size_info;
@@ -2227,10 +2226,10 @@ void DavinciModel::CreateOutput(uint32_t index, const OpDescPtr &op_desc, InputO
       dims[i] = shape.GetDim(i);
     }
   } else {                                                                    // FOR FORMAT_NHWC or FORMAT_NCHW
-    dims[0] = shape.GetDim(format == FORMAT_NHWC ? NHWC_DIM_N : NCHW_DIM_N);  // 0: first dim
-    dims[1] = shape.GetDim(format == FORMAT_NHWC ? NHWC_DIM_C : NCHW_DIM_C);  // 1: second dim
-    dims[2] = shape.GetDim(format == FORMAT_NHWC ? NHWC_DIM_H : NCHW_DIM_H);  // 2: third dim
-    dims[3] = shape.GetDim(format == FORMAT_NHWC ? NHWC_DIM_W : NCHW_DIM_W);  // 3: forth dim
+    dims[0] = shape.GetDim((format == FORMAT_NHWC) ? NHWC_DIM_N : NCHW_DIM_N);  // 0: first dim
+    dims[1] = shape.GetDim((format == FORMAT_NHWC) ? NHWC_DIM_C : NCHW_DIM_C);  // 1: second dim
+    dims[2] = shape.GetDim((format == FORMAT_NHWC) ? NHWC_DIM_H : NCHW_DIM_H);  // 2: third dim
+    dims[3] = shape.GetDim((format == FORMAT_NHWC) ? NHWC_DIM_W : NCHW_DIM_W);  // 3: forth dim
   }
   output.shape_info.num = dims[0];      // 0: first dim
   output.shape_info.channel = dims[1];  // 1: second dim
@@ -2741,7 +2740,7 @@ Status DavinciModel::ReturnResult(uint32_t data_id, const bool rslt_flg, const b
   }
 
   if (!has_output_node_) {
-    GELOGW("Output tensor list is empty, model id: %u", model_id_);
+    GELOGW("The tensor list of output is empty, model id: %u", model_id_);
     GE_CHK_STATUS(listener_->OnComputeDone(model_id_, data_id, INTERNAL_ERROR, outputs),
                   "[Call][OnComputeDone] failed, model_id:%u, data_id:%u.", model_id_, data_id);
     return INTERNAL_ERROR;
@@ -3071,7 +3070,7 @@ Status DavinciModel::CreateKnownZeroCopyMap(const vector<void *> &inputs, const
     GELOGI("output %zu, v addr %p, r addr %p, p addr %p", i, addr_list[i], addr, outputs[i]);
   }
 
-  GELOGI("success, known input data info size: %zu, known output data info size: %zu",
+  GELOGI("create map for zero copy success, known input data info size: %zu, known output data info size: %zu",
          known_input_data_info_.size(), known_output_data_info_.size());
   return SUCCESS;
 }
@@ -3106,12 +3105,12 @@ Status DavinciModel::UpdateKnownZeroCopyAddr(vector<void *> &total_io_addrs, boo
       total_io_addrs[i] = known_output_data_info_.at(total_io_addrs[i]);
     }
   }
-  GELOGI("success, total io addrs size: %zu", total_io_addrs.size());
+  GELOGI("update known zero copy addr success, total io addrs size: %zu", total_io_addrs.size());
   return SUCCESS;
 }
 
 Status DavinciModel::UpdateKnownNodeArgs(const vector<void *> &inputs, const vector<void *> &outputs) {
-  GELOGI("DavinciModel::UpdateKnownNodeArgs in");
+  GELOGI("DavinciModel::UpdateKnownNodeArgs begin");
   GE_CHK_STATUS_RET(CreateKnownZeroCopyMap(inputs, outputs),
                     "[Call][CreateKnownZeroCopyMap] failed, model_id:%u.", model_id_);
   total_io_addrs_.clear();
@@ -3683,6 +3682,7 @@ Status DavinciModel::InitConstant(const OpDescPtr &op_desc) {
       elem_num = 1;
     }
     uint64_t *buff = reinterpret_cast<uint64_t *>(tensor->MutableData().data());
+    GE_CHECK_NOTNULL(buff);
     if (ge::CheckInt64Uint32MulOverflow(elem_num, kBytes * kStringHeadElems) != SUCCESS) {
       GELOGE(FAILED, "[Call][CheckInt64Uint32MulOverflow] Shape size:%ld is invalid", elem_num);
       return FAILED;

ge/graph/load/model_manager/model_manager.cc

@@ -569,6 +569,7 @@ Status ModelManager::DataInputTensor(uint32_t model_id, const std::vector<ge::Te
       uint32_t length = static_cast<uint32_t>(cur_dynamic_dims.size() * sizeof(int32_t));
       GE_CHK_BOOL_EXEC(memcpy_s(data.data, length, cur_dynamic_dims.data(), length) == EOK,
                        REPORT_CALL_ERROR("E19999", "memcpy data failed, size:%u", length);
+                       delete[] reinterpret_cast<int32_t *>(data.data);
                        return INTERNAL_ERROR, "[Memcpy][Data] failed, size:%u.", length);
       data.length = length;
       input_data.blobs.push_back(data);
@@ -1790,7 +1791,8 @@ Status ModelManager::LaunchKernelCheckAicpuOp(std::vector<std::string> &aicpu_op
       std::vector<char> op_name;
       op_name.clear();
       op_name.resize(kOpNameMaxSize);
-      GE_CHK_RT(rtMemcpy(op_name.data(), aicpu_info.opLen, reinterpret_cast<void *>(aicpu_info.opType),
+      GE_CHK_RT(rtMemcpy(op_name.data(), aicpu_info.opLen,
+                         reinterpret_cast<void *>(static_cast<uintptr_t>(aicpu_info.opType)),
                          aicpu_info.opLen, RT_MEMCPY_DEVICE_TO_HOST));
       std::string kernel_type =
           (static_cast<OpKernelType>(aicpu_info.kernelsType) == TF_KERNEL) ? "TF_KERNEL" : "CPU_KERNEL";

ge/graph/load/model_manager/task_info/hccl_task_info.cc

@@ -329,7 +329,7 @@ void HcclTaskInfo::GetPrivateDefByTaskDef(const domi::TaskDef &task) {
   // Get privateDef and opsKernelStorePtr from taskDef and save them in taskInfo
   GELOGI("get custom info in modelTaskDef.");
   ops_kernel_store_ = nullptr;
-  void *ops_kernel_store_name_temp = reinterpret_cast<void *>(task.ops_kernel_store_ptr());
+  void *ops_kernel_store_name_temp = reinterpret_cast<void *>(static_cast<uintptr_t>(task.ops_kernel_store_ptr()));
   if (ops_kernel_store_name_temp != nullptr) {
     ops_kernel_store_ = std::move(ops_kernel_store_name_temp);
     std::string private_def_temp = task.private_def();

ge/graph/load/model_manager/task_info/kernel_ex_task_info.cc

@@ -420,7 +420,7 @@ Status KernelExTaskInfo::Distribute() {
   // xxxxxxxx xxxxxxxx xxxxxxxx xx10xxxx: HOST_ONLY
   // xxxxxxxx xxxxxxxx xxxxxxxx xx11xxxx: HOST_FIRST
   if (topic_type_flag_ > 0) {
-    dump_flag_ = dump_flag_ | topic_type_flag_;
+    dump_flag_ = dump_flag_ | static_cast<uint32_t>(topic_type_flag_);
   }
   rtError_t rt_ret = rtKernelLaunchEx(kernel_buf_, kernel_buf_size_, dump_flag_, stream_);
   if (rt_ret != RT_ERROR_NONE) {

ge/graph/load/model_manager/task_info/kernel_task_info.cc

@@ -436,7 +436,7 @@ Status KernelTaskInfo::Distribute() {
       // xxxxxxxx xxxxxxxx xxxxxxxx xx01xxxx: DEVICE_FIRST
       // xxxxxxxx xxxxxxxx xxxxxxxx xx10xxxx: HOST_ONLY
       // xxxxxxxx xxxxxxxx xxxxxxxx xx11xxxx: HOST_FIRST
-      dump_flag_ = dump_flag_ | topic_type_flag_;
+      dump_flag_ = dump_flag_ | static_cast<uint32_t>(topic_type_flag_);
     }
     GELOGI("distribute task info kernel_type %d, flag %d", kernel_type_, dump_flag_);
     // blockDim is reserved parameter, set to 1

ge/graph/load/model_manager/zero_copy_offset.cc

@@ -62,7 +62,8 @@ Status ZeroCopyOffset::InitInputDataInfo(int64_t output_size, void *virtual_addr
     for (size_t index = 0; index < zero_copy_basic_offset_.size(); ++index) {
       if (zero_copy_basic_offset_.at(index) == virtual_addr_offset) {
         out_count++;
-        uint64_t out_offset = reinterpret_cast<uint64_t>(virtual_addr) + zero_copy_relative_offset_.at(index);
+        uint64_t out_offset = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(virtual_addr)) +
+                              zero_copy_relative_offset_.at(index);
         data_info_.emplace_back(output_size, reinterpret_cast<void *>(static_cast<uintptr_t>(out_offset)));
         relative_offset_.emplace_back(zero_copy_relative_offset_.at(index));
         GELOGI("[ZCPY] virtual_addr: %p has been l2-fusion to %lu, need copy data_size is %ld.", basic_addr_,
@@ -117,7 +118,8 @@ Status ZeroCopyOffset::InitOutputDataInfo(const vector<int64_t> &input_size_list
     for (size_t index = 0; index < zero_copy_basic_offset_.size(); ++index) {
       if (zero_copy_basic_offset_.at(index) == virtual_addr_offset) {
         in_count++;
-        uint64_t in_offset = reinterpret_cast<uint64_t>(virtual_addr_list[idx]) + zero_copy_relative_offset_.at(index);
+        uint64_t in_offset = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(virtual_addr_list[idx])) +
+                             zero_copy_relative_offset_.at(index);
         int64_t real_data_size = ModelUtils::GetInputSize(op_desc).at(idx);
         data_info_.emplace_back(real_data_size, reinterpret_cast<void *>(static_cast<uintptr_t>(in_offset)));
         relative_offset_.emplace_back(zero_copy_relative_offset_.at(index));

ge/graph/manager/graph_manager.h

@@ -32,7 +32,6 @@
 #include "external/ge/ge_api_types.h"
 #include "graph/build/graph_builder.h"
 #include "graph/ge_local_context.h"
-#include "graph/load/graph_loader.h"
 #include "graph/manager/graph_manager_utils.h"
 #include "graph/manager/util/variable_accelerate_ctrl.h"
 #include "graph/optimize/graph_optimize.h"

ge/hybrid/executor/worker/execution_engine.cc

@@ -428,7 +428,7 @@ Status ExecutionEngine::ValidateInputTensors(const NodeState &node_state, const
       continue;
     }
 
-    int64_t expected_size;
+    int64_t expected_size = 0;
     (void)TensorUtils::GetSize(*tensor_desc, expected_size);
     GELOGD("[%s] Input[%d] expects [%ld] bytes.", task_context.GetNodeName(), i, expected_size);
     auto size_diff = expected_size - static_cast<int64_t>(input_tensor->GetSize());

ge/hybrid/model/hybrid_model_builder.cc

@@ -900,6 +900,7 @@ Status HybridModelBuilder::LoadGraph() {
     GE_CHECK_NOTNULL(node_item);
     AscendString graph_name;
     GE_CHK_GRAPH_STATUS_RET(it.second->GetGraph().GetName(graph_name), "Failed to get subgraph name");
+    GE_CHECK_NOTNULL(graph_name.GetString());
     auto subgraph = hybrid_model_.GetRootGraph()->GetSubgraph(graph_name.GetString());
     GE_CHECK_NOTNULL(subgraph);
     GE_CHK_STATUS_RET(IdentifyVariableOutputs(*node_item, subgraph),
@@ -945,7 +946,7 @@ Status HybridModelBuilder::VarNodeToTensor(const NodePtr &var_node, std::unique_
   }
 
   int64_t var_size = CalcVarSizeInBytes(*tensor_desc);
-  // var size is only for checking, will not allocate any memory by it
+  GE_CHECK_GE(var_size, 0);
   tensor.reset(new(std::nothrow)TensorValue(dev_mem, static_cast<size_t>(var_size)));
   GE_CHECK_NOTNULL(tensor);
   GELOGI("Get var memory addr %p for node %s, size = %ld, mem_type=%u", dev_mem, var_name.c_str(), var_size, mem_type);
@@ -967,6 +968,7 @@ Status HybridModelBuilder::HandleDtString(const GeTensor &tensor, void *var_addr
 
     auto &mutable_tensor = const_cast<GeTensor &>(tensor);
     uint64_t *buff = reinterpret_cast<uint64_t *>(mutable_tensor.MutableData().data());
+    GE_CHECK_NOTNULL(buff);
     GE_CHK_BOOL_RET_STATUS(ge::CheckInt64Uint32MulOverflow(elem_num, kBytes * kStringHeadElems) == SUCCESS, FAILED,
                            "[Invoke][CheckInt64Uint32MulOverflow] failed because Shape size is invalid.");
     auto offset = static_cast<uint64_t>(elem_num * kBytes * kStringHeadElems);

ge/hybrid/node_executor/hccl/hccl_node_executor.cc

@@ -417,7 +417,7 @@ Status BuildGatherAllToAllParams(TaskContext &context, HcomGatherAllToAllVParams
   }
   params.recvtype = iter->second;
 
-  int64_t addr_len;
+  int64_t addr_len = 0;
   (void) ge::AttrUtils::GetInt(op_desc, "addr_length", addr_len);
   params.addrLength = static_cast<int>(addr_len);
 
@@ -460,6 +460,7 @@ Status AllToAllNodeTask::ExecuteAsync(TaskContext &context, std::function<void()
       return FAILED;
     }
     HcomGatherAllToAllVParams params;
+    params.group = nullptr;
     GE_CHK_STATUS_RET(BuildGatherAllToAllParams(context, params));
     HcclResult hccl_ret = HcomExecEnqueueGatherAllToAllV(params, callback);
     if (hccl_ret != HCCL_SUCCESS) {

ge/ir_build/ge_ir_build.cc

@@ -867,6 +867,7 @@ graphStatus aclgrphDumpGraph(const ge::Graph &graph, const char *file, const siz
 graphStatus aclgrphGenerateForOp(const AscendString &op_type, const vector<TensorDesc> &inputs,
                                  const vector<TensorDesc> &outputs, Graph &graph) {
   ErrorManager::GetInstance().SetStage(error_message::kModelCompile, error_message::kOther);
+  GE_CHECK_NOTNULL(op_type.GetString());
   auto op_type_str = std::string(op_type.GetString());
   auto op_name = op_type_str + "_" + std::to_string(ge::GetCurrentTimestamp());
   auto op_desc = ge::MakeShared<ge::OpDesc>(op_name, op_type_str);

ge/single_op/single_op.cc

@@ -58,7 +58,7 @@ Status ProfilingTaskInfo(OpTask *op_task, const string &shape_type) {
          tmp_task_desc_info.op_name.c_str(), tmp_task_desc_info.model_name.c_str());
 
   tmp_task_desc_info.shape_type = shape_type;
-  tmp_task_desc_info.cur_iter_num = 0;
+  tmp_task_desc_info.cur_iter_num = ProfilingManager::Instance().GetStepInfoIndex();
   tmp_task_desc_info.task_type = op_task->GetTaskType();
 
   std::vector<TaskDescInfo> task_desc_info;

metadef

@@ -1 +1 @@
-Subproject commit 84e7ab39b0daf7ca2b2f5549e3279647da7875e2
+Subproject commit 3ace5b6f10e0af784a1c3211fd769d6e8860e864

parser

@@ -1 +1 @@
-Subproject commit ffd94df471f7dd2b1928cc8d27e43e7210aaa7e7
+Subproject commit db68a1a4f1a6ae69dbf9a5f338392d50ea3874e3

tests/depends/mmpa/src/mmpa_stub.cc

@@ -381,3 +381,8 @@ INT32 mmGetPid()
 {
   return (INT32)getpid();
 }
+
+INT32 mmSetCurrentThreadName(const CHAR *name)
+{
+  return EN_OK;
+}

tests/ut/ge/common/dump_properties_unittest.cc

@@ -115,12 +115,12 @@ TEST_F(UTEST_dump_properties, init_by_options_success_2) {
   EXPECT_EQ(st, SUCCESS);
 }
 
-TEST_F(UTEST_dump_properties, init_by_options_failed) {
+TEST_F(UTEST_dump_properties, init_by_options_success_3) {
   DumpProperties dp;
   std::map<std::string, std::string> options {{OPTION_EXEC_ENABLE_DUMP_DEBUG, "1"},
                                               {OPTION_EXEC_DUMP_PATH, "/tmp/"}};
   GetThreadLocalContext().SetGlobalOption(options);
   Status st = dp.InitByOptions();
-  EXPECT_NE(st, SUCCESS);
+  EXPECT_EQ(st, SUCCESS);
 }
 }  // namespace ge

tests/ut/ge/graph/load/model_manager_unittest.cc

@@ -54,31 +54,13 @@ class UtestModelManagerModelManager : public testing::Test {
   }
 
   void SetUp() {}
-
   void TearDown() {}
 
-  void CreateGraph(Graph &graph) {
-    TensorDesc desc(ge::Shape({1, 3, 224, 224}));
-    uint32_t size = desc.GetShape().GetShapeSize();
-    desc.SetSize(size);
-    auto data = op::Data("Data").set_attr_index(0);
-    data.update_input_desc_data(desc);
-    data.update_output_desc_out(desc);
-
-    auto flatten = op::Flatten("Flatten").set_input_x(data, data.name_out_out());
-
-    std::vector<Operator> inputs{data};
-    std::vector<Operator> outputs{flatten};
-    std::vector<Operator> targets{flatten};
-    // Graph graph("test_graph");
-    graph.SetInputs(inputs).SetOutputs(outputs).SetTargets(targets);
-  }
-
   void GenUnencryptModelData(ModelData &data) {
     const int model_len = 10;
     data.model_len = sizeof(ModelFileHeader) + model_len;
     data.model_data = new uint8_t[data.model_len];
-    memset((uint8_t *)data.model_data + sizeof(ModelFileHeader), 0, model_len);
+    memset(data.model_data, 0, data.model_len);
 
     ModelFileHeader *header = (ModelFileHeader *)data.model_data;
     header->magic = MODEL_FILE_MAGIC_NUM;
@@ -88,19 +70,6 @@ class UtestModelManagerModelManager : public testing::Test {
     header->is_checksum = ModelCheckType::CHECK;
   }
 
-  void GenEncryptModelData(ModelData &data) {
-    const int model_len = 10;
-    data.key = ENC_KEY;
-    data.model_data = new uint8_t[data.model_len];
-    uint8_t data_ori[model_len];
-    memset(data_ori, 0, model_len);
-    ModelFileHeader *header = (ModelFileHeader *)data.model_data;
-    header->magic = MODEL_FILE_MAGIC_NUM;
-    header->version = MODEL_VERSION;
-    header->is_encrypt = ModelEncryptType::ENCRYPTED;
-    header->length = 10;  // encrypt_len;
-  }
-
   void LoadStandardModelData(ModelData &data) {
     data.model_len = 512;
     data.model_data = new uint8_t[data.model_len];