!664 Synchronize latest Ascend software suite 18 Dec 2020

From: @nicholas_yhr
Reviewed-by: @youui,@guoqi1024,@liujunzhu
Signed-off-by: @guoqi1024

CMakeLists.txt

@@ -16,8 +16,11 @@ endif()
 
 if(DEFINED ENV{D_PKG_SERVER})
     set(GE_PB_PKG $ENV{D_PKG_SERVER})
-    message("Download packages from PKG server")
-endif()
+    message("Download packages from DPKG server")
+elseif(DEFINED ENV{MSLIBS_SERVER})
+    set(GE_PB_PKG "http://$ENV{MSLIBS_SERVER}:8081")
+    message("Download packages from MSPKG server")
+endif ()
 
 set(ASCEND_DRIVER_DIR ${ASCEND_DIR}/driver/lib64)
 set(ASCEND_DRIVER_COMMON_DIR ${ASCEND_DIR}/driver/lib64/common)
@@ -37,7 +40,7 @@ set(ATLAS_MS_RUNTIME_PATH ${ATLAS_RUNTIME_DIR} ${ATLAS_ACL_DIR} ${ATLAS_ATC_DIR}
 option(ENABLE_OPEN_SRC "Enable graphengine compile in opensource." FALSE)
 
 if (ENABLE_OPEN_SRC)
-    set(HI_PYTHON python3.7)
+    set(HI_PYTHON python3)
 
     include(cmake/external_libs/protobuf_shared.cmake)
     include(cmake/external_libs/protobuf_static.cmake)
@@ -71,7 +74,7 @@ if (ENABLE_OPEN_SRC)
         set(STATIC_ACL_LIB ${GE_LIB_PATH})
         find_module(slog libslog.so ${GE_LIB_PATH})
         find_module(static_mmpa libmmpa.a ${GE_LIB_PATH})
-        find_module(msprof libmsprof.so ${GE_LIB_PATH})
+        find_module(msprofiler libmsprofiler.a ${GE_LIB_PATH})
         find_module(hccl libhccl.so ${GE_LIB_PATH})
         find_module(adump_server libadump_server.a ${GE_LIB_PATH})
         find_module(runtime libruntime.so ${GE_LIB_PATH})
@@ -80,20 +83,19 @@ if (ENABLE_OPEN_SRC)
         find_module(error_manager liberror_manager.so ${GE_LIB_PATH})
         find_module(ascend_hal_stub libascend_hal.so ${GE_LIB_PATH})
         find_module(error_manager_static liberror_manager.a ${GE_LIB_PATH})
-        find_module(msprofiler libmsprofiler.a ${GE_LIB_PATH})
+        find_module(msprofiler_fwk libmsprofiler_fwk.a ${GE_LIB_PATH})
         #find_module(ascendcl_static libascendcl.a ${GE_LIB_PATH})
     else()
         find_module(slog libslog.so ${ASCEND_ATC_DIR} ${ASCEND_DRIVER_COMMON_DIR})
         find_module(static_mmpa libmmpa.a ${ASCEND_ATC_DIR} ${ASCEND_RUNTIME_DIR})
         find_module(error_manager liberror_manager.so ${ASCEND_ATC_DIR} ${ASCEND_RUNTIME_DIR})
         if(PLATFORM STREQUAL "train")
-            find_module(msprof libmsprof.so ${ASCEND_DRIVER_COMMON_DIR})
             find_module(hccl libhccl.so ${ASCEND_RUNTIME_DIR})
             find_module(adump_server libadump_server.a ${ASCEND_RUNTIME_DIR})
             find_module(runtime libruntime.so ${ASCEND_RUNTIME_DIR})
             find_module(resource libresource.so ${ASCEND_RUNTIME_DIR})
             find_module(error_manager liberror_manager.so ${ASCEND_RUNTIME_DIR})
-            find_module(msprofiler libmsprofiler.a ${ASCEND_RUNTIME_DIR})
+            find_module(msprofiler_fwk libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR})
             find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver)
             if(PRODUCT STREQUAL "flr3")
                 message(FATAL_ERROR "This platform is not supported in train mode, build terminated")
@@ -106,20 +108,17 @@ if (ENABLE_OPEN_SRC)
             find_module(error_manager liberror_manager.so ${ASCEND_ATC_DIR})
             find_module(error_manager_static liberror_manager.a ${ASCEND_ACL_DIR})
             find_module(msprofiler libmsprofiler.a ${ASCEND_ACL_DIR})
-	        #find_module(ascendcl_static libascendcl.a ${ASCEND_ACL_DIR})
+            #find_module(ascendcl_static libascendcl.a ${ASCEND_ACL_DIR})
             if(PRODUCT STREQUAL "flr3")
-                find_module(msprof libmsprof.so ${ASCEND_DRIVER_SHARE_DIR})
             elseif(PRODUCT STREQUAL "flr1")
                 find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver)
-                find_module(msprof libmsprof.so ${ASCEND_DRIVER_COMMON_DIR})
             elseif(PRODUCT STREQUAL "flr2")
                 # flr2 ascend_hal_stub limsprof ?
             else()
                 find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR})
-                find_module(msprof libmsprof.so ${ASCEND_DRIVER_DIR})
             endif()
         elseif(PLATFORM STREQUAL "all")
-            find_module(msprof libmsprof.so ${ASCEND_DRIVER_COMMON_DIR})
+            find_module(msprofiler libmsprofiler.a ${ASCEND_DRIVER_COMMON_DIR})
             find_module(hccl libhccl.so ${ASCEND_RUNTIME_DIR})
             find_module(adump_server libadump_server.a ${ASCEND_ACL_DIR})
             find_module(runtime libruntime.so ${ASCEND_ACL_DIR})
@@ -127,14 +126,14 @@ if (ENABLE_OPEN_SRC)
             find_module(resource libresource.so ${ASCEND_ATC_DIR})
             find_module(error_manager liberror_manager.so ${ASCEND_ATC_DIR})
             find_module(error_manager_static liberror_manager.a ${ASCEND_ACL_DIR})
-            find_module(msprofiler libmsprofiler.a ${ASCEND_ACL_DIR})
+            find_module(msprofiler_fwk libmsprofiler_fwk.a ${ASCEND_ACL_DIR})
             find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver)
             #find_module(ascendcl_static libascendcl.a ${ASCEND_ACL_DIR})
         else()
-	    message(STATUS "PLATFORM param is invalid, should be train or inference, you choose nothing!")
+            message(STATUS "PLATFORM param is invalid, should be train or inference, you choose nothing!")
         endif()
 
-	if (ENABLE_GE_COV OR ENABLE_GE_UT)
+        if (ENABLE_GE_COV OR ENABLE_GE_UT)
             add_subdirectory(tests)
         endif()
 

build.sh

@@ -23,7 +23,7 @@ export BUILD_PATH="${BASEPATH}/build/"
 usage()
 {
   echo "Usage:"
-  echo "sh build.sh [-j[n]] [-h] [-v] [-s] [-t] [-u] [-c] [-S on|off]"
+  echo "sh build.sh [-j[n]] [-h] [-v] [-s] [-t] [-u] [-c] [-S on|off] [-M]"
   echo ""
   echo "Options:"
   echo "    -h Print usage"
@@ -35,6 +35,7 @@ usage()
   echo "    -p Build inference or train"
   echo "    -v Display build command"
   echo "    -S Enable enable download cmake compile dependency from gitee , default off"
+  echo "    -M build MindSpore mode"
   echo "to be continued ..."
 }
 
@@ -62,8 +63,9 @@ checkopts()
   PLATFORM=""
   PRODUCT="normal"
   ENABLE_GITEE="off"
+  MINDSPORE_MODE="off"
   # Process the options
-  while getopts 'ustchj:p:g:vS:' opt
+  while getopts 'ustchj:p:g:vS:M' opt
   do
     OPTARG=$(echo ${OPTARG} | tr '[A-Z]' '[a-z]')
     case "${opt}" in
@@ -104,6 +106,9 @@ checkopts()
         ENABLE_GITEE="$OPTARG"
         echo "enable download from gitee"
         ;;
+      M)
+        MINDSPORE_MODE="on"
+        ;;
       *)
         echo "Undefined option: ${opt}"
         usage
@@ -113,8 +118,8 @@ checkopts()
 }
 checkopts "$@"
 
-git submodule update --init metadef
-git submodule update --init parser
+#git submodule update --init metadef
+#git submodule update --init parser
 
 mk_dir() {
     local create_dir="$1"  # the target to make
@@ -150,7 +155,13 @@ build_graphengine()
   if [[ "X$ENABLE_GITEE" = "Xon" ]]; then
     CMAKE_ARGS="${CMAKE_ARGS} -DENABLE_GITEE=ON"
   fi
-  CMAKE_ARGS="${CMAKE_ARGS} -DENABLE_OPEN_SRC=True -DCMAKE_INSTALL_PREFIX=${OUTPUT_PATH} -DPLATFORM=${PLATFORM} -DPRODUCT=${PRODUCT}"
+
+  if [[ "X$MINDSPORE_MODE" = "Xoff" ]]; then
+    CMAKE_ARGS="${CMAKE_ARGS} -DENABLE_OPEN_SRC=True -DCMAKE_INSTALL_PREFIX=${OUTPUT_PATH} -DPLATFORM=${PLATFORM} -DPRODUCT=${PRODUCT}"
+  else
+    CMAKE_ARGS="${CMAKE_ARGS} -DENABLE_D=ON -DCMAKE_INSTALL_PREFIX=${OUTPUT_PATH}"
+  fi
+
   echo "${CMAKE_ARGS}"
   cmake ${CMAKE_ARGS} ..
   if [ $? -ne 0 ]
@@ -169,6 +180,9 @@ build_graphengine()
   elif [ "X$ENABLE_GE_UT" = "Xon" ]
   then
     TARGET="ut_libgraph ut_libge_multiparts_utest ut_libge_others_utest ut_libge_kernel_utest ut_libge_distinct_load_utest"
+  elif [ "X$MINDSPORE_MODE" = "Xon" ]
+  then
+    TARGET="ge_common graph"
   elif [ "x${PLATFORM}" = "xall" ]
   then
     # build all the target
@@ -314,7 +328,13 @@ generate_package()
   fi
 }
 
-if [[ "X$ENABLE_GE_UT" = "Xoff" ]]; then
+if [[ "X$ENABLE_GE_UT" = "Xoff" && "X$MINDSPORE_MODE" = "Xoff" ]]; then
   generate_package
+  echo "---------------- GraphEngine package archive generated ----------------"
+elif [ "X$MINDSPORE_MODE" = "Xon" ]
+then
+  cd "${OUTPUT_PATH}"
+  find ./ -name graphengine_lib.tar -exec rm {} \;
+  tar -cf graphengine_lib.tar lib
 fi
-echo "---------------- GraphEngine package archive generated ----------------"
+

cmake/external_libs/gflags.cmake

@@ -23,6 +23,7 @@ ExternalProject_Add(gflags_build
                     URL ${REQ_URL}
                     #URL /home/txd/workspace/linux_cmake/pkg/protobuf-3.8.0.tar.gz
                     #SOURCE_DIR ${GE_CODE_DIR}/../../third_party/gflags/src/gflags-2.2.2 
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ${CMAKE_COMMAND} -DCMAKE_CXX_FLAGS=${gflags_CXXFLAGS} -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}/gflags <SOURCE_DIR>
                     BUILD_COMMAND $(MAKE)
                     INSTALL_COMMAND $(MAKE) install

cmake/external_libs/gtest.cmake

@@ -10,7 +10,10 @@ if ((${CMAKE_INSTALL_PREFIX} STREQUAL /usr/local) OR
     message(STATUS "No install prefix selected, default to ${CMAKE_INSTALL_PREFIX}.")
 endif()
 
-if (ENABLE_GITEE)
+if (GE_PB_PKG)
+    set(REQ_URL "${GE_PB_PKG}/libs/gtest/release-1.8.0.tar.gz")
+    set(MD5 "")
+elseif (ENABLE_GITEE)
     set(REQ_URL "https://gitee.com/mirrors/googletest/repository/archive/release-1.8.0.tar.gz")
     set(MD5 "")
 else()
@@ -22,8 +25,9 @@ set (gtest_CXXFLAGS "-D_GLIBCXX_USE_CXX11_ABI=0 -D_FORTIFY_SOURCE=2 -O2 -fstack-
 set (gtest_CFLAGS "-D_GLIBCXX_USE_CXX11_ABI=0 -D_FORTIFY_SOURCE=2 -O2 -fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack")
 ExternalProject_Add(gtest_build
                     URL ${REQ_URL}
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ${CMAKE_COMMAND} -DCMAKE_CXX_FLAGS=${gtest_CXXFLAGS} -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}/gtest <SOURCE_DIR>
-		    -DBUILD_TESTING=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_MACOSX_RPATH=TRUE -Dgtest_disable_pthreads=ON
+                -DBUILD_TESTING=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_MACOSX_RPATH=TRUE -Dgtest_disable_pthreads=ON
                     BUILD_COMMAND $(MAKE)
                     INSTALL_COMMAND $(MAKE) install
                     EXCLUDE_FROM_ALL TRUE 

cmake/external_libs/json.cmake

@@ -5,10 +5,14 @@ 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")
+if (GE_PB_PKG)
+    set(REQ_URL "${GE_PB_PKG}/libs/ge_nlohmann_json/include.zip")
+    set(MD5 "0dc903888211db3a0f170304cd9f3a89")
+    set(JSON_INCLUDE_DIR ${JSON_SRC_DIR})
+#elseif (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")
@@ -18,6 +22,7 @@ ExternalProject_Add(json_build
                     URL ${REQ_URL}
                     #URL /home/txd/workspace/cloud_code/pkg/include.zip
                     SOURCE_DIR  ${JSON_SRC_DIR}
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ""
                     BUILD_COMMAND ""
                     INSTALL_COMMAND ""

cmake/external_libs/onnx.cmake

@@ -6,7 +6,10 @@ set(ONNX_PROTO_DIR ${CMAKE_BINARY_DIR}/onnx)
 set(ONNX_PROTO_FILE ${ONNX_PROTO_DIR}/onnx.proto)
 file(MAKE_DIRECTORY ${ONNX_PROTO_DIR})
 
-if (ENABLE_GITEE)
+if (GE_PB_PKG)
+    set(REQ_URL "${GE_PB_PKG}/libs/onnx/onnx-1.6.0.tar.gz")
+    set(MD5 "512f2779d6215d4a36f366b6b9acdf1e")
+elseif (ENABLE_GITEE)
     set(REQ_URL "https://gitee.com/mirrors/ONNX/repository/archive/v1.6.0.tar.gz")
     set(MD5 "1bdbcecdd68ea8392630467646776e02")
 else()
@@ -19,6 +22,7 @@ ExternalProject_Add(onnx
                     #URL /home/txd/workspace/cloud_code/pkg/onnx-1.6.0.tar.gz
                     #URL_HASH SHA256=3b88c3fe521151651a0403c4d131cb2e0311bd28b753ef692020a432a81ce345
                     #SOURCE_DIR ${ONNX_SRC_DIR}
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ""
                     BUILD_COMMAND ""
                     #INSTALL_COMMAND "" 

cmake/external_libs/protobuf_shared.cmake

@@ -26,6 +26,7 @@ set(protobuf_CXXFLAGS "-Wno-maybe-uninitialized -Wno-unused-parameter -fPIC -fst
 set(protobuf_LDFLAGS "-Wl,-z,relro,-z,now,-z,noexecstack")
 ExternalProject_Add(protobuf_build
                     URL ${REQ_URL}
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ${CMAKE_COMMAND}
                     -Dprotobuf_WITH_ZLIB=OFF
                     -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR}

cmake/external_libs/protobuf_static.cmake

@@ -27,6 +27,7 @@ ExternalProject_Add(protobuf_static_build
                     URL ${REQ_URL}
                     #URL /home/txd/workspace/linux_cmake/pkg/protobuf-3.8.0.tar.gz
                     #SOURCE_DIR ${METADEF_DIR}/../../third_party/protobuf/src/protobuf-3.8.0
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ${CMAKE_COMMAND}
                     -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                     -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}

cmake/external_libs/protoc.cmake

@@ -30,6 +30,7 @@ ExternalProject_Add(protoc_build
                     URL ${REQ_URL}
                     #URL /home/txd/workspace/linux_cmake/pkg/protobuf-3.8.0.tar.gz
                     #SOURCE_DIR ${GE_CODE_DIR}/../third_party/protobuf/src/protobuf-3.8.0
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ${CMAKE_COMMAND} -Dprotobuf_WITH_ZLIB=OFF -Dprotobuf_BUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_CXX_FLAGS=${protobuf_CXXFLAGS} -DCMAKE_CXX_LDFLAGS=${protobuf_LDFLAGS} -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}/protoc <SOURCE_DIR>/cmake
                     BUILD_COMMAND $(MAKE)
                     INSTALL_COMMAND $(MAKE) install

cmake/external_libs/securec.cmake

@@ -10,11 +10,20 @@ if ((${CMAKE_INSTALL_PREFIX} STREQUAL /usr/local) OR
     message(STATUS "No install prefix selected, default to ${CMAKE_INSTALL_PREFIX}.")
 endif()
 
+if (GE_PB_PKG)
+    set(REQ_URL "${GE_PB_PKG}/libs/securec/v1.1.10.tar.gz")
+    set(MD5 "")
+else()
+    set(REQ_URL "https://gitee.com/openeuler/libboundscheck/repository/archive/v1.1.10.tar.gz")
+    set(MD5 "")
+endif ()
+
 ExternalProject_Add(c_sec_build
-                    URL https://gitee.com/openeuler/libboundscheck/repository/archive/v1.1.10.tar.gz
-                    #URL /home/txd/workspace/linux_cmake/pkg/protobuf-3.8.0.tar.gz
+                    URL ${REQ_URL}
+                    #URL https://gitee.com/openeuler/libboundscheck/repository/archive/v1.1.10.tar.gz
                     #SOURCE_DIR ${GE_CODE_DIR}/../libc_sec
                     PATCH_COMMAND patch -p1 < ${GE_CODE_DIR}/metadef/third_party/patch/securec/0001-add-securec-cmake-script.patch
+                    TLS_VERIFY OFF
                     CONFIGURE_COMMAND ${CMAKE_COMMAND}
                     -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                     -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}

ge/CMakeLists.txt

@@ -60,6 +60,8 @@ set(TRAIN_SRC_LIST
     "common/dump/dump_manager.cc"
     "common/dump/dump_properties.cc"
     "common/dump/dump_op.cc"
+    "common/profiling/ge_profiling.cc"
+    "common/profiling/ge_runner_profiling.cc"
     "engine_manager/dnnengine_manager.cc"
     "ge_local_engine/engine/host_cpu_engine.cc"
     "generator/ge_generator.cc"
@@ -142,6 +144,7 @@ set(TRAIN_SRC_LIST
     "graph/passes/atomic_addr_clean_pass.cc"
     "graph/passes/mark_same_addr_pass.cc"
     "graph/passes/mark_graph_unknown_status_pass.cc"
+    "graph/passes/dynamic_single_op_reset_shape_pass.cc"
     "graph/passes/mark_agnostic_pass.cc"
     "graph/partition/dynamic_shape_partition.cc"
     "graph/partition/stage_partition.cc"
@@ -201,6 +204,7 @@ set(TRAIN_SRC_LIST
     "host_kernels/sub_kernel.cc"
     "host_kernels/transdata_kernel.cc"
     "host_kernels/unpack_kernel.cc"
+    "host_kernels/reformat_kernel.cc"
     "graph/passes/folding_pass.cc"
     "graph/passes/get_original_format_pass.cc"
     "graph/passes/guarantee_const_pass.cc"
@@ -331,7 +335,6 @@ set(TRAIN_SRC_LIST
     "hybrid/hybrid_davinci_model.cc"
     "executor/ge_executor.cc"
     "client/ge_api.cc"
-    "client/ge_prof.cc"
     "analyzer/analyzer.cc"
     "ir_build/ge_ir_build.cc"
     "ir_build/atc_ir_common.cc"
@@ -432,6 +435,7 @@ set(INFER_SRC_LIST
     "graph/passes/atomic_addr_clean_pass.cc"
     "graph/passes/mark_same_addr_pass.cc"
     "graph/passes/mark_graph_unknown_status_pass.cc"
+    "graph/passes/dynamic_single_op_reset_shape_pass.cc"
     "graph/passes/mark_agnostic_pass.cc"
     "graph/common/omg_util.cc"
     "graph/common/bcast.cc"
@@ -487,6 +491,7 @@ set(INFER_SRC_LIST
     "host_kernels/slice_d_kernel.cc"
     "host_kernels/dynamic_stitch_kernel.cc"
     "host_kernels/identity_kernel.cc"
+    "host_kernels/reformat_kernel.cc"
     "graph/passes/stop_gradient_pass.cc"
     "graph/passes/prevent_gradient_pass.cc"
     "graph/passes/identity_pass.cc"
@@ -602,7 +607,7 @@ set(INFER_SRC_LIST
 
 if (NOT ENABLE_D AND NOT ENABLE_ACL AND NOT ENABLE_MS_TESTCASES)
 ############ libge_runner.so ############
-add_library(ge_runner SHARED ${TRAIN_SRC_LIST} ${PROTO_SRCS} ${PROTO_CLIENT_SRCS})
+add_library(ge_runner SHARED ${TRAIN_SRC_LIST} ${PROTO_SRCS} ${PROTO_CLIENT_SRCS} $<TARGET_OBJECTS:msprofiler_fwk>)
 
 target_compile_definitions(ge_runner PRIVATE
     PROTOBUF_INLINE_NOT_IN_HEADERS=0
@@ -647,7 +652,6 @@ target_link_libraries(ge_runner
     $<BUILD_INTERFACE:intf_pub>
     ge_memory
     adump_server
-    msprofiler
     static_mmpa
     -Wl,--no-as-needed
     graph
@@ -656,7 +660,6 @@ target_link_libraries(ge_runner
     register
     c_sec
     slog
-    msprof
     runtime
     resource
     error_manager
@@ -781,7 +784,6 @@ target_link_libraries(opensrc_ascendcl PRIVATE
                      c_sec
                      runtime
                      slog
-                     msprof
                      ascend_hal_stub
                      -Wl,--as-needed
                      -lrt
@@ -797,12 +799,10 @@ set_target_properties(opensrc_ascendcl PROPERTIES
 add_custom_command(
     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/stub_ge_ir_build.cc
            ${CMAKE_CURRENT_BINARY_DIR}/stub_ge_api.cc
-           ${CMAKE_CURRENT_BINARY_DIR}/stub_ge_prof.cc
     COMMAND echo "Generating stub files."
             && ${HI_PYTHON} ${CMAKE_CURRENT_LIST_DIR}/stub/gen_stubapi.py ${GE_CODE_DIR}/inc/external ${CMAKE_CURRENT_BINARY_DIR}
             && mv ge_ir_build.cc stub_ge_ir_build.cc
             && mv ge_api.cc stub_ge_api.cc
-            && mv ge_prof.cc stub_ge_prof.cc
             &&  echo "Generating stub files end."
     #WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     #DEPENDS stub/gen_stubapi.py ${TOP_DIR}/inc/external ${CMAKE_CURRENT_BINARY_DIR}
@@ -811,7 +811,6 @@ add_custom_command(
 add_custom_target(ge_stub
     DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/stub_ge_ir_build.cc
             ${CMAKE_CURRENT_BINARY_DIR}/stub_ge_api.cc
-            ${CMAKE_CURRENT_BINARY_DIR}/stub_ge_prof.cc
 )
 
 ##################################################################
@@ -853,7 +852,6 @@ target_include_directories(atc_stub_ge_compiler PRIVATE
 ############ stub/libge_runner.so ############
 add_library(fwk_stub_ge_runner SHARED
     stub_ge_api.cc
-    stub_ge_prof.cc
     stub_ge_ir_build.cc
 )
 

ge/client/ge_api.cc

@@ -134,7 +134,7 @@ Status GEInitialize(const std::map<string, string> &options) {
 
 Status GEInitialize(const std::map<AscendString, AscendString> &options) {
   std::map<std::string, std::string> str_options;
-  for (auto & option : options) {
+  for (auto &option : options) {
     if (option.first.GetString() == nullptr || option.second.GetString() == nullptr) {
       GELOGE(FAILED, "GEInitialize options is nullptr.");
       return FAILED;

ge/client/ge_prof.cc

@@ -1,369 +0,0 @@
-/**
- * Copyright 2020 Huawei Technologies Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "ge/ge_prof.h"
-#include "ge/ge_api.h"
-#include "init/gelib.h"
-#include "common/debug/log.h"
-#include "framework/common/debug/ge_log.h"
-#include "common/profiling/profiling_manager.h"
-#include "graph/load/graph_loader.h"
-#include "toolchain/prof_acl_api.h"
-
-using std::map;
-using std::string;
-using std::vector;
-
-namespace {
-const uint32_t kMaxDeviceNum = 64;
-const uint32_t kDeviceListIndex = 3;
-const std::string kProfilingInit = "prof_init";
-const std::string kProfilingFinalize = "prof_finalize";
-const std::string kProfilingStart = "prof_start";
-const std::string kProfilingStop = "prof_stop";
-const std::string kDeviceNums = "devNums";
-const std::string kDeviceIdList = "devIdList";
-const std::string kAicoreMetrics = "aicoreMetrics";
-
-const std::map<ge::ProfilingAicoreMetrics, std::string> kProfAicoreMetricsToString = {
-    {ge::kAicoreArithmaticThroughput, "AICORE_ARITHMATIC_THROUGHPUT"},
-    {ge::kAicorePipeline, "AICORE_PIPELINE"},
-    {ge::kAicoreSynchronization, "AICORE_SYNCHRONIZATION"},
-    {ge::kAicoreMemory, "AICORE_MEMORY"},
-    {ge::kAicoreInternalMemory, "AICORE_INTERNAL_MEMORY"},
-    {ge::kAicoreStall, "AICORE_STALL"}};
-}  // namespace
-
-static bool g_graph_prof_init_ = false;
-static std::mutex g_prof_mutex_;
-
-namespace ge {
-struct aclgrphProfConfig {
-  ProfConfig config;
-};
-
-Status aclgrphProfInit(const char *profiler_path, uint32_t length) {
-  GELOGT(TRACE_INIT, "Graph prof init start");
-
-  std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
-  if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Ge client is not initialized.");
-    return FAILED;
-  }
-
-  std::lock_guard<std::mutex> lock(g_prof_mutex_);
-  if (g_graph_prof_init_) {
-    GELOGW("Multi graph profiling initializations.");
-    return GE_PROF_MULTI_INIT;
-  }
-
-  Status ret = CheckPath(profiler_path, length);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Profiling config path is invalid.");
-    return ret;
-  }
-  // if command mode is set, just return
-  if (ProfilingManager::Instance().ProfilingOn()) {
-    GELOGW("Graph prof init failed, cause profiling command pattern is running.");
-    return GE_PROF_MODE_CONFLICT;
-  }
-
-  ret = ProfInit(profiler_path);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "ProfInit init fail");
-    return ret;
-  }
-
-  GraphLoader graph_loader;
-  Command command;
-  command.cmd_params.clear();
-  command.cmd_type = kProfilingInit;
-  command.module_index = PROF_MODEL_LOAD;
-  ret = graph_loader.CommandHandle(command);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Handle profiling command %s failed, config = %s", kProfilingInit.c_str(), profiler_path);
-    return ret;
-  }
-  if (!g_graph_prof_init_) {
-    g_graph_prof_init_ = true;
-    GELOGI("Profiling init successfully.");
-  }
-
-  GELOGI("Successfully execute GraphProfInit.");
-  return SUCCESS;
-}
-
-Status aclgrphProfFinalize() {
-  std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
-  if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Ge client is not initialized.");
-    return FAILED;
-  }
-  std::lock_guard<std::mutex> lock(g_prof_mutex_);
-  // if command mode is set, just return
-  if (ProfilingManager::Instance().ProfilingOn()) {
-    GELOGW("Graph prof finalize failed, cause profiling command pattern is running.");
-    return GE_PROF_MODE_CONFLICT;
-  }
-
-  if (!g_graph_prof_init_) {
-    GELOGE(GE_PROF_NOT_INIT, "Graph not profiling initialize.");
-    return GE_PROF_NOT_INIT;
-  }
-  GraphLoader graph_loader;
-  Command command;
-  command.cmd_params.clear();
-  command.cmd_type = kProfilingFinalize;
-  Status ret = graph_loader.CommandHandle(command);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Handle profiling command %s failed.", kProfilingFinalize.c_str());
-    return ret;
-  }
-
-  ret = ProfFinalize();
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Finalize profiling failed, result = %d", ret);
-  }
-
-  if (ret == SUCCESS) {
-    g_graph_prof_init_ = false;
-    GELOGI("Successfully execute GraphProfFinalize.");
-  }
-  return ret;
-}
-
-bool TransProfConfigToParam(const aclgrphProfConfig *profiler_config, vector<string> &prof_config_params) {
-  prof_config_params.clear();
-  prof_config_params.emplace_back(kDeviceNums);
-  prof_config_params.emplace_back(std::to_string(profiler_config->config.devNums));
-  prof_config_params.emplace_back(kDeviceIdList);
-  std::string devID = "";
-  if (profiler_config->config.devNums == 0) {
-    GELOGW("The device num is invalid.");
-    return false;
-  }
-  for (uint32_t i = 0; i < profiler_config->config.devNums; i++) {
-    devID.append(std::to_string(profiler_config->config.devIdList[i]));
-    if (i != profiler_config->config.devNums - 1) {
-      devID.append(",");
-    }
-  }
-
-  prof_config_params.push_back(devID);
-  prof_config_params.push_back(kAicoreMetrics);
-  auto iter =
-      kProfAicoreMetricsToString.find(static_cast<ProfilingAicoreMetrics>(profiler_config->config.aicoreMetrics));
-  if (iter == kProfAicoreMetricsToString.end()) {
-    GELOGW("The prof aicore metrics is invalid.");
-    return false;
-  }
-  prof_config_params.push_back(iter->second);
-  return true;
-}
-
-bool isProfConfigValid(const uint32_t *deviceid_list, uint32_t device_nums) {
-  if (deviceid_list == nullptr) {
-    GELOGE(PARAM_INVALID, "deviceIdList is nullptr");
-    return false;
-  }
-  if (device_nums == 0 || device_nums > kMaxDeviceNum) {
-    GELOGE(PARAM_INVALID, "The device nums is invalid.");
-    return false;
-  }
-
-  // real device num
-  int32_t dev_count = 0;
-  rtError_t rt_err = rtGetDeviceCount(&dev_count);
-  if (rt_err != RT_ERROR_NONE) {
-    GELOGE(INTERNAL_ERROR, "Get the Device count fail.");
-    return false;
-  }
-
-  if (device_nums > static_cast<uint32_t>(dev_count)) {
-    GELOGE(PARAM_INVALID, "Device num(%u) is not in range 1 ~ %d.", device_nums, dev_count);
-    return false;
-  }
-
-  std::unordered_set<uint32_t> record;
-  for (size_t i = 0; i < device_nums; ++i) {
-    uint32_t dev_id = deviceid_list[i];
-    if (dev_id >= static_cast<uint32_t>(dev_count)) {
-      GELOGE(PARAM_INVALID, "Device id %u is not in range 0 ~ %d(exclude %d)", dev_id, dev_count, dev_count);
-      return false;
-    }
-    if (record.count(dev_id) > 0) {
-      GELOGE(PARAM_INVALID, "Device id %u is duplicatedly set", dev_id);
-      return false;
-    }
-    record.insert(dev_id);
-  }
-  return true;
-}
-
-aclgrphProfConfig *aclgrphProfCreateConfig(uint32_t *deviceid_list, uint32_t device_nums,
-                                           ProfilingAicoreMetrics aicore_metrics, ProfAicoreEvents *aicore_events,
-                                           uint64_t data_type_config) {
-  if (!isProfConfigValid(deviceid_list, device_nums)) {
-    return nullptr;
-  }
-  aclgrphProfConfig *config = new (std::nothrow) aclgrphProfConfig();
-  if (config == nullptr) {
-    GELOGE(INTERNAL_ERROR, "new aclgrphProfConfig fail");
-    return nullptr;
-  }
-  config->config.devNums = device_nums;
-  if (memcpy_s(config->config.devIdList, sizeof(config->config.devIdList), deviceid_list,
-               device_nums * sizeof(uint32_t)) != EOK) {
-    GELOGE(INTERNAL_ERROR, "copy devID failed. size = %u", device_nums);
-    delete config;
-    return nullptr;
-  }
-
-  config->config.aicoreMetrics = static_cast<ProfAicoreMetrics>(aicore_metrics);
-  config->config.dataTypeConfig = data_type_config;
-  GELOGI("Successfully create prof config.");
-  return config;
-}
-
-Status aclgrphProfDestroyConfig(aclgrphProfConfig *profiler_config) {
-  if (profiler_config == nullptr) {
-    GELOGE(PARAM_INVALID, "destroy profilerConfig failed, profilerConfig must not be nullptr");
-    return PARAM_INVALID;
-  }
-
-  delete profiler_config;
-  GELOGI("Successfully destroy prof config.");
-  return SUCCESS;
-}
-
-Status aclgrphProfStart(aclgrphProfConfig *profiler_config) {
-  if (profiler_config == nullptr) {
-    GELOGE(PARAM_INVALID, "aclgrphProfConfig is invalid.");
-    return FAILED;
-  }
-  std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
-  if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Ge client is not initialized.");
-    return FAILED;
-  }
-
-  std::lock_guard<std::mutex> lock(g_prof_mutex_);
-  // if command mode is set, just return
-  if (ProfilingManager::Instance().ProfilingOn()) {
-    GELOGW("Graph prof finalize failed, cause profiling command pattern is running.");
-    return GE_PROF_MODE_CONFLICT;
-  }
-  if (!g_graph_prof_init_) {
-    GELOGE(GE_PROF_NOT_INIT, "Graph not profiling initialize.");
-    return GE_PROF_NOT_INIT;
-  }
-
-  Status ret = ProfStartProfiling(&profiler_config->config);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Start profiling failed, prof result = %d", ret);
-    return FAILED;
-  }
-
-  std::vector<string> prof_params;
-  if (!TransProfConfigToParam(profiler_config, prof_params)) {
-    GELOGE(PARAM_INVALID, "Transfer profilerConfig to string vector failed");
-    return PARAM_INVALID;
-  }
-
-  GraphLoader graph_loader;
-  Command command;
-  command.cmd_params.clear();
-  command.cmd_type = kProfilingStart;
-  command.cmd_params = prof_params;
-  command.module_index = profiler_config->config.dataTypeConfig;
-  GELOGI("Profiling will start, device nums:%s , deviceID:[%s], data type config: 0x%llx", prof_params[0].c_str(),
-         prof_params[kDeviceListIndex].c_str(), command.module_index);
-  ret = graph_loader.CommandHandle(command);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Handle profiling command failed");
-    return FAILED;
-  }
-
-  GELOGI("Successfully execute GraphProfStartProfiling.");
-
-  return SUCCESS;
-}
-
-Status aclgrphProfStop(aclgrphProfConfig *profiler_config) {
-  if (profiler_config == nullptr) {
-    GELOGE(PARAM_INVALID, "aclgrphProfConfig is invalid.");
-    return FAILED;
-  }
-  std::shared_ptr<GELib> instance_ptr = ge::GELib::GetInstance();
-  if (instance_ptr == nullptr || !instance_ptr->InitFlag()) {
-    GELOGE(GE_CLI_GE_NOT_INITIALIZED, "Ge client is not initialized.");
-    return FAILED;
-  }
-
-  std::lock_guard<std::mutex> lock(g_prof_mutex_);
-  // if command mode is set, just return
-  if (ProfilingManager::Instance().ProfilingOn()) {
-    GELOGW("Graph prof finalize failed, cause profiling command pattern is running.");
-    return GE_PROF_MODE_CONFLICT;
-  }
-  if (!g_graph_prof_init_) {
-    GELOGE(GE_PROF_NOT_INIT, "Graph not profiling initialize.");
-    return GE_PROF_NOT_INIT;
-  }
-
-  for (uint32_t i = 0; i < profiler_config->config.devNums; i++) {
-    uint64_t data_type_config;
-    Status status = ProfGetDataTypeConfig(profiler_config->config.devIdList[i], data_type_config);
-    if (status != SUCCESS) {
-      GELOGE(status, "Prof get data type config failed, prof result = %d", status);
-      return status;
-    }
-    if (data_type_config != profiler_config->config.dataTypeConfig) {
-      GELOGE(FAILED, "data type config verify failed");
-      return FAILED;
-    }
-  }
-
-  std::vector<string> prof_params;
-  if (!TransProfConfigToParam(profiler_config, prof_params)) {
-    GELOGE(PARAM_INVALID, "Transfer profilerConfig to string vector failed");
-    return PARAM_INVALID;
-  }
-
-  GraphLoader graph_loader;
-  Command command;
-  command.cmd_params.clear();
-  command.cmd_type = kProfilingStop;
-  command.cmd_params = prof_params;
-  command.module_index = profiler_config->config.dataTypeConfig;
-  GELOGI("Profiling will stop, device nums:%s , deviceID:[%s], data type config: 0x%llx", prof_params[0].c_str(),
-         prof_params[kDeviceListIndex].c_str(), command.module_index);
-  Status ret = graph_loader.CommandHandle(command);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Handle profiling command failed");
-    return FAILED;
-  }
-
-  ret = ProfStopProfiling(&profiler_config->config);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Stop profiling failed, prof result = %d", ret);
-    return ret;
-  }
-
-  GELOGI("Successfully execute GraphProfStopProfiling.");
-  return SUCCESS;
-}
-}  // namespace ge

ge/client/module.mk

@@ -4,7 +4,6 @@ LOCAL_PATH := $(call my-dir)
 COMMON_LOCAL_SRC_FILES := \
     proto/ge_api.proto \
     ge_api.cc \
-    ge_prof.cc \
 
 
 COMMON_LOCAL_C_INCLUDES := \
@@ -69,9 +68,9 @@ LOCAL_SHARED_LIBRARIES := \
     libgraph \
     libregister \
     libge_compiler \
-    libge_common \
-    libmsprof
+    libge_common
 
+LOCAL_STATIC_LIBRARIES += libmsprofiler_fwk \
 
 
 LOCAL_LDFLAGS := -lrt -ldl
@@ -104,8 +103,10 @@ LOCAL_SHARED_LIBRARIES := \
     libregister \
     libruntime \
     libge_compiler \
-    libge_common \
-    libmsprof
+    libge_common
+
+
+LOCAL_STATIC_LIBRARIES += libmsprofiler_fwk \
 
 
 LOCAL_LDFLAGS := -lrt -ldl

ge/common/CMakeLists.txt

@@ -24,6 +24,7 @@ set(SRC_LIST
     "helper/om_file_helper.cc"
     "helper/model_helper.cc"
     "../model/ge_model.cc"
+    "../model/ge_root_model.cc"
     "auth/file_saver.cc"
     "fp16_t.cc"
     "math/fp16_math.cc"
@@ -129,6 +130,7 @@ target_compile_definitions(ge_common_static PRIVATE
     google=ascend_private
     $<IF:$<STREQUAL:${TARGET_SYSTEM_NAME},Windows>,OS_TYPE=WIN,OS_TYPE=0>
     $<$<STREQUAL:${TARGET_SYSTEM_NAME},Windows>:SECUREC_USING_STD_SECURE_LIB=0 NOMINMAX>
+    LOG_CPP
 )
 
 target_compile_options(ge_common_static PRIVATE
@@ -183,6 +185,7 @@ target_compile_options(ge_common PRIVATE
     -fvisibility=hidden
     -O2
     -Werror
+    -Wno-deprecated-declarations
 )
 
 target_include_directories(ge_common PRIVATE

ge/common/auth/file_saver.cc

@@ -54,8 +54,8 @@ Status FileSaver::OpenFile(int32_t &fd, const std::string &file_path) {
 Status FileSaver::WriteData(const void *data, uint32_t size, int32_t fd) {
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(size == 0 || data == nullptr, return PARAM_INVALID);
   mmSsize_t write_count;
-  uint32_t size_2g = ((uint32_t) 0x1 << 31);
-  uint32_t size_1g = ((uint32_t) 0x1 << 30);
+  uint32_t size_2g = 2147483648;  // 0x1 << 31
+  uint32_t size_1g = 1073741824;  // 0x1 << 30
   // Write data
   if (size > size_2g) {
     auto seek = reinterpret_cast<uint8_t *>(const_cast<void *>(data));
@@ -258,6 +258,65 @@ FileSaver::SaveToFile(const string &file_path, ModelFileHeader &file_header, Mod
   return SUCCESS;
 }
 
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status
+FileSaver::SaveToFile(const string &file_path, ModelFileHeader &file_header,
+                      vector<ModelPartitionTable *> &model_partition_tables,
+                      const vector<vector<ModelPartition>> &all_partition_datas) {
+  file_header.is_encrypt = ModelEncryptType::UNENCRYPTED;
+
+  const Status ret = SaveWithFileHeader(file_path, file_header, model_partition_tables, all_partition_datas);
+  GE_CHK_BOOL_RET_STATUS(ret == SUCCESS, FAILED, "save file failed, file_path:%s, file header len:%u.",
+                         file_path.c_str(), file_header.length);
+  return SUCCESS;
+}
+
+Status FileSaver::SaveWithFileHeader(const std::string &file_path, const ModelFileHeader &file_header,
+                                     vector<ModelPartitionTable *> &model_partition_tables,
+                                     const vector<vector<ModelPartition>> &all_partition_datas) {
+
+  GE_CHK_BOOL_EXEC(model_partition_tables.size() == all_partition_datas.size(),
+                   return PARAM_INVALID,
+                   "model table size %zu does not match partition size %zu",
+                   model_partition_tables.size(), all_partition_datas.size())
+  for (size_t index = 0; index < model_partition_tables.size(); ++index) {
+    auto &cur_partiton_data = all_partition_datas[index];
+    auto &cur_model_partition_table = *model_partition_tables[index];
+    GE_CHK_BOOL_RET_STATUS(!cur_partiton_data.empty() && cur_model_partition_table.num != 0
+                           && cur_model_partition_table.num == cur_partiton_data.size(), FAILED,
+                           "Invalid param:partition data size is (%u), model_partition_table.num is (%zu).",
+                           cur_model_partition_table.num, cur_partiton_data.size());
+  }
+
+  // Open file
+  int32_t fd = 0;
+  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(OpenFile(fd, file_path) != SUCCESS, return FAILED);
+  Status ret = SUCCESS;
+  do {
+    // Write file header
+    GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
+        WriteData(static_cast<const void *>(&file_header), sizeof(ModelFileHeader), fd) != SUCCESS, ret = FAILED;
+        break);
+    for (size_t index = 0; index < model_partition_tables.size(); ++index) {
+      // Write model partition table
+      auto &cur_tabel = *model_partition_tables[index];
+      uint32_t table_size = static_cast<uint32_t>(SIZE_OF_MODEL_PARTITION_TABLE(cur_tabel));
+      GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
+          WriteData(static_cast<const void *>(&cur_tabel), table_size, fd) != SUCCESS, ret = FAILED; break);
+      // Write partition data
+      auto &cur_partition_datas = all_partition_datas[index];
+      for (const auto &partition_data : cur_partition_datas) {
+        GELOGI("GC:size[%zu]", partition_data.size);
+        GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
+            WriteData(static_cast<const void *>(partition_data.data), partition_data.size, fd) != SUCCESS, ret = FAILED;
+            break);
+      }
+    }
+  } while (0);
+  // Close file
+  GE_CHK_BOOL_RET_STATUS(mmClose(fd) == EN_OK, FAILED, "Close file failed.");
+  return ret;
+}
+
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status FileSaver::SaveToFile(const string &file_path, const void *data,
                                                                               int len) {
   if (data == nullptr || len <= 0) {

ge/common/auth/file_saver.h

@@ -74,6 +74,10 @@ class FileSaver {
                            ModelPartitionTable &model_partition_table,
                            const std::vector<ModelPartition> &partition_datas);
 
+  static Status SaveToFile(const string &file_path, ModelFileHeader &file_header,
+                        vector<ModelPartitionTable *> &model_partition_tables,
+                        const vector<vector<ModelPartition>> &all_partition_datas);
+
   static Status SaveToBuffWithFileHeader(const ModelFileHeader &file_header,
                                             ModelPartitionTable &model_partition_table,
                                             const std::vector<ModelPartition> &partitionDatas,
@@ -108,6 +112,9 @@ class FileSaver {
   static Status SaveWithFileHeader(const std::string &file_path, const ModelFileHeader &file_header,
                                    ModelPartitionTable &model_partition_table,
                                    const std::vector<ModelPartition> &partition_datas);
+  static Status SaveWithFileHeader(const std::string &file_path, const ModelFileHeader &file_header,
+                                       vector<ModelPartitionTable *> &model_partition_tables,
+                                       const vector<vector<ModelPartition>> &all_partition_datas);
 };
 }  // namespace ge
 #endif  // GE_COMMON_AUTH_FILE_SAVER_H_

ge/common/base64.h

@@ -25,32 +25,38 @@
 
 namespace ge {
 namespace {
-const char* kBase64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                           "abcdefghijklmnopqrstuvwxyz"
-                           "0123456789+/";
+const char *kBase64Chars =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  "abcdefghijklmnopqrstuvwxyz"
+  "0123456789+/";
 const char kEqualSymbol = '=';
 const size_t kBase64CharsNum = 64;
 const size_t kThreeByteOneGroup = 3;
 const size_t kFourByteOneGroup = 4;
-}
+const size_t kThreeByteOneGroupIndex0 = 0;
+const size_t kThreeByteOneGroupIndex1 = 1;
+const size_t kThreeByteOneGroupIndex2 = 2;
+const size_t kFourByteOneGroupIndex0 = 0;
+const size_t kFourByteOneGroupIndex1 = 1;
+const size_t kFourByteOneGroupIndex2 = 2;
+const size_t kFourByteOneGroupIndex3 = 3;
+}  // namespace
 
 namespace base64 {
-static inline bool IsBase64Char(const char &c) {
-  return (isalnum(c) || (c == '+') || (c == '/'));
-}
+static inline bool IsBase64Char(const char &c) { return (isalnum(c) || (c == '+') || (c == '/')); }
 
 static std::string EncodeToBase64(const std::string &raw_data) {
   size_t encode_length = raw_data.size() / kThreeByteOneGroup * kFourByteOneGroup;
   encode_length += raw_data.size() % kThreeByteOneGroup == 0 ? 0 : kFourByteOneGroup;
-  size_t raw_data_index = 0 ;
+  size_t raw_data_index = 0;
   size_t encode_data_index = 0;
   std::string encode_data;
   encode_data.resize(encode_length);
 
   for (; raw_data_index + kThreeByteOneGroup <= raw_data.size(); raw_data_index += kThreeByteOneGroup) {
     auto char_1 = static_cast<uint8_t>(raw_data[raw_data_index]);
-    auto char_2 = static_cast<uint8_t>(raw_data[raw_data_index + 1]);
-    auto char_3 = static_cast<uint8_t>(raw_data[raw_data_index + 2]);
+    auto char_2 = static_cast<uint8_t>(raw_data[raw_data_index + kThreeByteOneGroupIndex1]);
+    auto char_3 = static_cast<uint8_t>(raw_data[raw_data_index + kThreeByteOneGroupIndex2]);
     encode_data[encode_data_index++] = kBase64Chars[char_1 >> 2u];
     encode_data[encode_data_index++] = kBase64Chars[((char_1 << 4u) & 0x30) | (char_2 >> 4u)];
     encode_data[encode_data_index++] = kBase64Chars[((char_2 << 2u) & 0x3c) | (char_3 >> 6u)];
@@ -80,8 +86,7 @@ static std::string EncodeToBase64(const std::string &raw_data) {
 #pragma GCC diagnostic ignored "-Wunused-function"
 static Status DecodeFromBase64(const std::string &base64_data, std::string &decode_data) {
   if (base64_data.size() % kFourByteOneGroup != 0) {
-    GELOGE(PARAM_INVALID, "base64 data size must can be divided by 4, but given data size is %zu",
-           base64_data.size());
+    GELOGE(PARAM_INVALID, "base64 data size must can be divided by 4, but given data size is %zu", base64_data.size());
     return PARAM_INVALID;
   }
   decode_data.clear();
@@ -92,10 +97,10 @@ static Status DecodeFromBase64(const std::string &base64_data, std::string &deco
     return static_cast<uint8_t>(std::distance(kBase64Chars, char_pos)) & 0xff;
   };
 
-  for (std::size_t input_data_index = 0; input_data_index < base64_data_len; input_data_index += 4) {
+  for (std::size_t input_data_index = 0; input_data_index < base64_data_len; input_data_index += kFourByteOneGroup) {
     for (size_t i = 0; i < kFourByteOneGroup; ++i) {
       if (base64_data[input_data_index + i] == kEqualSymbol &&
-          input_data_index >= base64_data_len - 4 && i > 1) {
+          input_data_index >= base64_data_len - kFourByteOneGroup && i > 1) {
         byte_4[i] = kBase64CharsNum;
       } else if (IsBase64Char(base64_data[input_data_index + i])) {
         byte_4[i] = FindCharInBase64Chars(base64_data[input_data_index + i]);
@@ -104,19 +109,23 @@ static Status DecodeFromBase64(const std::string &base64_data, std::string &deco
         return PARAM_INVALID;
       }
     }
-    decode_data += static_cast<char>((byte_4[0] << 2u) + ((byte_4[1] & 0x30) >> 4u));
-    if (byte_4[2] >= kBase64CharsNum){
+    decode_data +=
+      static_cast<char>((byte_4[kFourByteOneGroupIndex0] << 2u) + ((byte_4[kFourByteOneGroupIndex1] & 0x30) >> 4u));
+    if (byte_4[kFourByteOneGroupIndex2] >= kBase64CharsNum) {
       break;
-    } else if (byte_4[3] >= kBase64CharsNum) {
-      decode_data += static_cast<char>(((byte_4[1] & 0x0f) << 4u)  + ((byte_4[2] & 0x3c) >> 2u));
+    } else if (byte_4[kFourByteOneGroupIndex3] >= kBase64CharsNum) {
+      decode_data += static_cast<char>(((byte_4[kFourByteOneGroupIndex1] & 0x0f) << 4u) +
+                                       ((byte_4[kFourByteOneGroupIndex2] & 0x3c) >> 2u));
       break;
     }
-    decode_data += static_cast<char>(((byte_4[1] & 0x0f) << 4u)  + ((byte_4[2] & 0x3c) >> 2u));
-    decode_data += static_cast<char>(((byte_4[2] & 0x03) << 6u)  + byte_4[3]);
+    decode_data += static_cast<char>(((byte_4[kFourByteOneGroupIndex1] & 0x0f) << 4u) +
+                                     ((byte_4[kFourByteOneGroupIndex2] & 0x3c) >> 2u));
+    decode_data +=
+      static_cast<char>(((byte_4[kFourByteOneGroupIndex2] & 0x03) << 6u) + byte_4[kFourByteOneGroupIndex3]);
   }
   return SUCCESS;
 }
 #pragma GCC diagnostic pop
-}
+}  // namespace base64
 }  // namespace ge
 #endif  // GE_COMMON_BASE64_H_

ge/common/debug/memory_dumper.cc

@@ -139,7 +139,8 @@ int MemoryDumper::OpenFile(const char *filename) {
   GE_IF_BOOL_EXEC(
     -1 != path_split_pos, string prefix_path = std::string(filename).substr(0, path_split_pos);
     string last_path = std::string(filename).substr(path_split_pos, strlen(filename) - 1);
-    GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(prefix_path.length() >= MMPA_MAX_PATH, return kInvalidFd, "Prefix path is too long!");
+    GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(prefix_path.length() >= MMPA_MAX_PATH,
+        return kInvalidFd, "Prefix path is too long!");
     GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(mmRealPath(prefix_path.c_str(), tmp_path, MMPA_MAX_PATH) != EN_OK, return kInvalidFd,
                                    "Dir %s does not exit.", prefix_path.c_str());
     real_path = std::string(tmp_path) + last_path;)

ge/common/formats/format_transfers/format_transfer_fractal_nz.cc

@@ -23,12 +23,30 @@
 #include "common/formats/utils/formats_trans_utils.h"
 #include "framework/common/debug/ge_log.h"
 #include "framework/common/debug/log.h"
+#include "framework/common/types.h"
 #include "graph/utils/type_utils.h"
 
 namespace ge {
 namespace formats {
 namespace {
 const int kDimSize4D = 4;
+
+const size_t kSingleDim = 1;
+
+const size_t kNdDimIndexN = 0;
+const size_t kNdDimIndexH = 1;
+const size_t kNdDimIndexW = 2;
+
+const size_t kDimDValueBNdFNz = 2;  // dim d-value between Nd and FractalZz
+
+const size_t kNdDimCountBackwardsW = 1;
+const size_t kNdDimCountBackwardsWH = 2;
+
+const size_t kFNzDimCountBackwardsW0 = 1;
+const size_t kFNzDimCountBackwardsW0H0 = 2;
+const size_t kFNzDimCountBackwardsW0H0H1 = 3;
+const size_t kFNzDimCountBackwardsW0H0H1W1 = 4;
+
 bool IsDataTypeSupport(DataType data_type) { return GetSizeByDataType(data_type) > 0; }
 
 using ShapeVector = std::vector<int64_t>;
@@ -60,14 +78,14 @@ Status TransShapeToFracNz(const ShapeVector &src_shape, DataType data_type, Shap
   auto w0 = GetCubeSizeByDataType(data_type);
   int64_t h0 = kCubeSize;
   switch (src_shape.size()) {
-    case 1:
-      dst_shape.push_back(Ceil(src_shape[0], w0));
-      dst_shape.push_back(1);
+    case kSingleDim:
+      dst_shape.push_back(Ceil(src_shape[kNdDimIndexN], w0));
+      dst_shape.push_back(DIM_DEFAULT_VALUE);
       dst_shape.push_back(h0);
       dst_shape.push_back(w0);
-      hw_shape.push_back(1);
-      hw_shape.push_back(1);
-      hw_shape.push_back(src_shape[0]);
+      hw_shape.push_back(DIM_DEFAULT_VALUE);
+      hw_shape.push_back(DIM_DEFAULT_VALUE);
+      hw_shape.push_back(src_shape[kNdDimIndexN]);
       if (!IsShapeValid(dst_shape)) {
         GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
         return PARAM_INVALID;
@@ -76,17 +94,17 @@ Status TransShapeToFracNz(const ShapeVector &src_shape, DataType data_type, Shap
     default:
       auto size = src_shape.size();
       int64_t times = 1;
-      for (size_t i = 0; i != size - 2; i++) {
+      for (size_t i = 0; i != size - kDimDValueBNdFNz; i++) {
         dst_shape.push_back(src_shape[i]);
         times *= src_shape[i];
       }
-      dst_shape.push_back(Ceil(src_shape[size - 1], w0));
-      dst_shape.push_back(Ceil(src_shape[size - 2], h0));
+      dst_shape.push_back(Ceil(src_shape[size - kNdDimCountBackwardsW], w0));
+      dst_shape.push_back(Ceil(src_shape[size - kNdDimCountBackwardsWH], h0));
       dst_shape.push_back(h0);
       dst_shape.push_back(w0);
       hw_shape.push_back(times);
-      hw_shape.push_back(src_shape[size - 2]);
-      hw_shape.push_back(src_shape[size - 1]);
+      hw_shape.push_back(src_shape[size - kNdDimCountBackwardsWH]);
+      hw_shape.push_back(src_shape[size - kNdDimCountBackwardsW]);
       if (!IsShapeValid(dst_shape)) {
         GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
         return PARAM_INVALID;
@@ -128,16 +146,16 @@ Status TransFormatFromNdToFracNz(const TransArgs &args, TransResult &result, con
   }
 
   // src&dst_shape can be written as times*H*W & times*W1*H1*H0*W0, respectively. dst_shape_size >= kDimNum4D
-  auto times = hw_shape.at(0);
-  auto h = hw_shape.at(1);
-  auto w = hw_shape.at(2);
+  auto times = hw_shape.at(kNdDimIndexN);
+  auto h = hw_shape.at(kNdDimIndexH);
+  auto w = hw_shape.at(kNdDimIndexW);
   auto hw = h * w;
 
   auto shape_size = args.dst_shape.size();
-  auto w1 = args.dst_shape[shape_size - 4];
-  auto h1 = args.dst_shape[shape_size - 3];
-  auto h0 = args.dst_shape[shape_size - 2];
-  auto w0 = args.dst_shape[shape_size - 1];
+  auto w1 = args.dst_shape[shape_size - kFNzDimCountBackwardsW0H0H1W1];
+  auto h1 = args.dst_shape[shape_size - kFNzDimCountBackwardsW0H0H1];
+  auto h0 = args.dst_shape[shape_size - kFNzDimCountBackwardsW0H0];
+  auto w0 = args.dst_shape[shape_size - kFNzDimCountBackwardsW0];
   auto h1h0 = h1 * h0;
   auto h1h0w0 = h1h0 * w0;
   auto w1h1h0w0 = w1 * h1h0w0;
@@ -198,16 +216,16 @@ Status TransFormatFromFracNzToNd(const TransArgs &args, TransResult &result, con
     return OUT_OF_MEMORY;
   }
 
-  auto times = dst_hw_shape.at(0);
-  auto h = dst_hw_shape.at(1);
-  auto w = dst_hw_shape.at(2);
+  auto times = dst_hw_shape.at(kNdDimIndexN);
+  auto h = dst_hw_shape.at(kNdDimIndexH);
+  auto w = dst_hw_shape.at(kNdDimIndexW);
   auto hw = h * w;
 
   auto shape_size = args.src_shape.size();
-  auto w1 = args.src_shape[shape_size - 4];
-  auto h1 = args.src_shape[shape_size - 3];
-  auto h0 = args.src_shape[shape_size - 2];
-  auto w0 = args.src_shape[shape_size - 1];
+  auto w1 = args.src_shape[shape_size - kFNzDimCountBackwardsW0H0H1W1];
+  auto h1 = args.src_shape[shape_size - kFNzDimCountBackwardsW0H0H1];
+  auto h0 = args.src_shape[shape_size - kFNzDimCountBackwardsW0H0];
+  auto w0 = args.src_shape[shape_size - kFNzDimCountBackwardsW0];
   auto h1h0 = h1 * h0;
   auto h1h0w0 = h1h0 * w0;
   auto w1h1h0w0 = w1 * h1h0w0;

ge/common/formats/format_transfers/format_transfer_fractal_zz.cc

@@ -23,12 +23,29 @@
 #include "common/formats/utils/formats_trans_utils.h"
 #include "framework/common/debug/ge_log.h"
 #include "framework/common/debug/log.h"
+#include "framework/common/types.h"
 #include "graph/utils/type_utils.h"
 
 namespace ge {
 namespace formats {
 namespace {
 const int kDimSize4D = 4;
+
+const size_t kSingleDim = 1;
+
+const size_t kNdDimIndexN = 0;
+const size_t kNdDimIndexH = 1;
+const size_t kNdDimIndexW = 2;
+
+const size_t kDimDValueBNdFZz = 2;  // dim d-value between Nd and FractalZz
+
+const size_t kNdDimCountBackwardsW = 1;
+const size_t kNdDimCountBackwardsWH = 2;
+
+const size_t kFZzDimCountBackwardsW0 = 1;
+const size_t kFZzDimCountBackwardsW0H0 = 2;
+const size_t kFZzDimCountBackwardsW0H0W1 = 3;
+const size_t kFZzDimCountBackwardsW0H0W1H1 = 4;
 bool IsDataTypeSupport(DataType d_type) { return GetSizeByDataType(d_type) > 0; }
 
 using ShapeVector = std::vector<int64_t>;
@@ -40,8 +57,8 @@ bool CheckShape(Format format, const ShapeVector &shape) {
     case FORMAT_NHWC:
       return CheckShapeValid(shape, kDimSize4D);
     default:
-      std::string error = "Trans format between " +  FmtToStr(TypeUtils::FormatToSerialString(format)) +
-          " and FORMAT_FRACTAL_ZZ is not supported.";
+      std::string error = "Trans format between " + FmtToStr(TypeUtils::FormatToSerialString(format)) +
+                          " and FORMAT_FRACTAL_ZZ is not supported.";
       GE_ERRORLOG_AND_ERRORMSG(PARAM_INVALID, error.c_str());
       return false;
   }
@@ -60,14 +77,14 @@ Status TransShapeToFracZz(const ShapeVector &src_shape, DataType data_type, Shap
   auto w0 = GetCubeSizeByDataType(data_type);
   auto h0 = GetCubeSizeByDataType(data_type);
   switch (src_shape.size()) {
-    case 1:
-      dst_shape.push_back(1);
-      dst_shape.push_back(Ceil(src_shape[0], w0));
+    case kSingleDim:
+      dst_shape.push_back(DIM_DEFAULT_VALUE);
+      dst_shape.push_back(Ceil(src_shape[kNdDimIndexN], w0));
       dst_shape.push_back(h0);
       dst_shape.push_back(w0);
-      hw_shape.push_back(1);
-      hw_shape.push_back(1);
-      hw_shape.push_back(src_shape[0]);
+      hw_shape.push_back(DIM_DEFAULT_VALUE);
+      hw_shape.push_back(DIM_DEFAULT_VALUE);
+      hw_shape.push_back(src_shape[kNdDimIndexN]);
       if (!IsShapeValid(dst_shape)) {
         GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
         return PARAM_INVALID;
@@ -76,17 +93,17 @@ Status TransShapeToFracZz(const ShapeVector &src_shape, DataType data_type, Shap
     default:
       auto size = src_shape.size();
       int64_t times = 1;
-      for (size_t i = 0; i != size - 2; i++) {
+      for (size_t i = 0; i != size - kDimDValueBNdFZz; i++) {
         dst_shape.push_back(src_shape[i]);
         times *= src_shape[i];
       }
-      dst_shape.push_back(Ceil(src_shape[size - 2], h0));
-      dst_shape.push_back(Ceil(src_shape[size - 1], w0));
+      dst_shape.push_back(Ceil(src_shape[size - kNdDimCountBackwardsWH], h0));
+      dst_shape.push_back(Ceil(src_shape[size - kNdDimCountBackwardsW], w0));
       dst_shape.push_back(h0);
       dst_shape.push_back(w0);
       hw_shape.push_back(times);
-      hw_shape.push_back(src_shape[size - 2]);
-      hw_shape.push_back(src_shape[size - 1]);
+      hw_shape.push_back(src_shape[size - kNdDimCountBackwardsWH]);
+      hw_shape.push_back(src_shape[size - kNdDimCountBackwardsW]);
       if (!IsShapeValid(dst_shape)) {
         GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
         return PARAM_INVALID;
@@ -127,16 +144,16 @@ Status TransFormatFromNdToFracZz(const TransArgs &args, TransResult &result, con
     return OUT_OF_MEMORY;
   }
   // The src&dst_shape can be written as times*H*W & times*H1*W1*H0*W0, respectively. dst_shape_size >= kDimNum4D
-  auto times = hw_shape.at(0);
-  auto h = hw_shape.at(1);
-  auto w = hw_shape.at(2);
+  auto times = hw_shape.at(kNdDimIndexN);
+  auto h = hw_shape.at(kNdDimIndexH);
+  auto w = hw_shape.at(kNdDimIndexW);
   auto hw = h * w;
 
   auto shape_size = args.dst_shape.size();
-  auto h1 = args.dst_shape[shape_size - 4];
-  auto w1 = args.dst_shape[shape_size - 3];
-  auto h0 = args.dst_shape[shape_size - 2];
-  auto w0 = args.dst_shape[shape_size - 1];
+  auto h1 = args.dst_shape[shape_size - kFZzDimCountBackwardsW0H0W1H1];
+  auto w1 = args.dst_shape[shape_size - kFZzDimCountBackwardsW0H0W1];
+  auto h0 = args.dst_shape[shape_size - kFZzDimCountBackwardsW0H0];
+  auto w0 = args.dst_shape[shape_size - kFZzDimCountBackwardsW0];
   auto h0w0 = h0 * w0;
   auto w1h0w0 = w1 * h0w0;
   auto h1w1h0w0 = h1 * w1h0w0;
@@ -155,8 +172,8 @@ Status TransFormatFromNdToFracZz(const TransArgs &args, TransResult &result, con
           auto src_offset = (src_h_head + w1_idx * w0) * size;
           auto dst_offset = (h0_head + w1_idx * h0w0) * 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);
+                                  ? dst_size - dst_offset
+                                  : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
           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) {
@@ -171,8 +188,8 @@ Status TransFormatFromNdToFracZz(const TransArgs &args, TransResult &result, con
           auto src_offset = (src_h_head + src_w_idx) * size;
           auto dst_offset = (w0_head + w0_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);
+                                  ? dst_size - dst_offset
+                                  : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
           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) {
@@ -205,16 +222,16 @@ Status TransFormatFromFracZzToNd(const TransArgs &args, TransResult &result, con
   }
 
   // The src&dst_shape can be written as times*H*W & times*H1*W1*H0*W0, respectively. dst_shape_size >= kDimNum4D
-  auto times = dst_hw_shape.at(0);
-  auto h = dst_hw_shape.at(1);
-  auto w = dst_hw_shape.at(2);
+  auto times = dst_hw_shape.at(kNdDimIndexN);
+  auto h = dst_hw_shape.at(kNdDimIndexH);
+  auto w = dst_hw_shape.at(kNdDimIndexW);
   auto hw = h * w;
 
   auto shape_size = args.src_shape.size();
-  auto h1 = args.src_shape[shape_size - 4];
-  auto w1 = args.src_shape[shape_size - 3];
-  auto h0 = args.src_shape[shape_size - 2];
-  auto w0 = args.src_shape[shape_size - 1];
+  auto h1 = args.src_shape[shape_size - kFZzDimCountBackwardsW0H0W1H1];
+  auto w1 = args.src_shape[shape_size - kFZzDimCountBackwardsW0H0W1];
+  auto h0 = args.src_shape[shape_size - kFZzDimCountBackwardsW0H0];
+  auto w0 = args.src_shape[shape_size - kFZzDimCountBackwardsW0];
   auto h0w0 = h0 * w0;
   auto w1h0w0 = w1 * h0w0;
   auto h1w1h0w0 = h1 * w1h0w0;
@@ -233,8 +250,8 @@ Status TransFormatFromFracZzToNd(const TransArgs &args, TransResult &result, con
           auto src_offset = (h0_head + w1_idx * h0w0) * size;
           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);
+                                  ? dst_size - dst_offset
+                                  : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
           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) {
@@ -249,8 +266,8 @@ Status TransFormatFromFracZzToNd(const TransArgs &args, TransResult &result, con
           auto dst_w_idx = w1_head + w0_idx;
           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);
+                                  ? dst_size - dst_offset
+                                  : static_cast<int64_t>(SECUREC_MEM_MAX_LEN);
           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_fz_c04.cc

@@ -35,7 +35,6 @@
  *      Padding to (N, ceil(Z/16)*16)
  *  Last Step: View the (N, ceil(Z/16)*16) as 4D (N/16, 16, C/16, 16) and transpose to (C/16, N/16, 16, 16)
  */
-
 namespace ge {
 namespace formats {
 namespace {

ge/common/formats/format_transfers/format_transfer_transpose.cc

@@ -19,6 +19,7 @@
 #include <securec.h>
 #include <memory>
 
+#include "common/formats/utils/formats_definitions.h"
 #include "common/formats/utils/formats_trans_utils.h"
 #include "framework/common/debug/ge_log.h"
 #include "framework/common/debug/log.h"
@@ -29,21 +30,21 @@ namespace formats {
 namespace {
 std::map<Format, std::map<Format, std::vector<int64_t>>> perm_args{
     {FORMAT_NCHW,
-     {{FORMAT_NHWC, std::vector<int64_t>({0, 2, 3, 1})},
-      {FORMAT_HWCN, std::vector<int64_t>({2, 3, 1, 0})},
-      {FORMAT_CHWN, std::vector<int64_t>({1, 2, 3, 0})}}},
+     {{FORMAT_NHWC, std::vector<int64_t>({kNchwN, kNchwH, kNchwW, kNchwC})},
+      {FORMAT_HWCN, std::vector<int64_t>({kNchwH, kNchwW, kNchwC, kNchwN})},
+      {FORMAT_CHWN, std::vector<int64_t>({kNchwC, kNchwH, kNchwW, kNchwN})}}},
     {FORMAT_NHWC,
-     {{FORMAT_NCHW, std::vector<int64_t>({0, 3, 1, 2})},
-      {FORMAT_CHWN, std::vector<int64_t>({3, 1, 2, 0})},
-      {FORMAT_HWCN, std::vector<int64_t>({1, 2, 3, 0})}}},
+     {{FORMAT_NCHW, std::vector<int64_t>({kNhwcN, kNhwcC, kNhwcH, kNhwcW})},
+      {FORMAT_CHWN, std::vector<int64_t>({kNhwcC, kNhwcH, kNhwcW, kNhwcN})},
+      {FORMAT_HWCN, std::vector<int64_t>({kNhwcH, kNhwcW, kNhwcC, kNhwcN})}}},
     {FORMAT_HWCN,
-     {{FORMAT_NCHW, std::vector<int64_t>({3, 2, 0, 1})},
-      {FORMAT_NHWC, std::vector<int64_t>({3, 0, 1, 2})},
-      {FORMAT_CHWN, std::vector<int64_t>({2, 0, 1, 3})}}},
+     {{FORMAT_NCHW, std::vector<int64_t>({kHwcnN, kHwcnC, kHwcnH, kHwcnW})},
+      {FORMAT_NHWC, std::vector<int64_t>({kHwcnN, kHwcnH, kHwcnW, kHwcnC})},
+      {FORMAT_CHWN, std::vector<int64_t>({kHwcnC, kHwcnH, kHwcnW, kHwcnN})}}},
     {FORMAT_CHWN,
-     {{FORMAT_NCHW, std::vector<int64_t>({3, 0, 1, 2})},
-      {FORMAT_NHWC, std::vector<int64_t>({3, 1, 2, 0})},
-      {FORMAT_HWCN, std::vector<int64_t>({1, 2, 0, 3})}}},
+     {{FORMAT_NCHW, std::vector<int64_t>({kChwnN, kChwnC, kChwnH, kChwnW})},
+      {FORMAT_NHWC, std::vector<int64_t>({kChwnN, kChwnH, kChwnW, kChwnC})},
+      {FORMAT_HWCN, std::vector<int64_t>({kChwnH, kChwnW, kChwnC, kChwnN})}}},
 };
 
 bool IsShapeArgValid(const std::vector<int64_t> &src_shape, const std::vector<int64_t> &perm_arg) {

ge/common/formats/utils/formats_definitions.h

@@ -23,6 +23,7 @@ static const int kCubeSize = 16;
 static const int kNiSize = 16;
 static const int64_t kShapeItemNumMAX = 1024UL * 1024UL * 1024UL * 1024UL;
 
+
 enum NchwDimIndex {
   kNchwN,
   kNchwC,
@@ -47,6 +48,14 @@ enum HwcnDimIndex {
   kHwcnDimsNum
 };
 
+enum ChwnDimIndex {
+  kChwnC,
+  kChwnH,
+  kChwnW,
+  kChwnN,
+  kChwnDimsNum
+};
+
 enum Nc1hwc0DimIndex {
   kNc1hwc0N,
   kNc1hwc0C1,

ge/common/ge/plugin_manager.cc

@@ -123,7 +123,10 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec
     if (handle == nullptr) {
       const char *error = mmDlerror();
       GE_IF_BOOL_EXEC(error == nullptr, error = "");
-      GELOGE(GE_PLGMGR_PATH_INVALID, "Failed to dlopen %s!", error);
+      ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"},
+          {"mmDlopen", "shared library path is " + FmtToStr(file_path_dlopen) + ". Errormessage" + FmtToStr(error)});
+      GELOGE(GE_PLGMGR_PATH_INVALID, "Failed to dlopen the shared library path[%s]. Errormessage[%s]!",
+             file_path_dlopen.c_str(), error);
       continue;
     }
 
@@ -132,6 +135,9 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec
     for (const auto &func_name : func_check_list) {
       auto real_fn = (void (*)())mmDlsym(handle, const_cast<char *>(func_name.c_str()));
       if (real_fn == nullptr) {
+        ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"},
+            {"mmDlsym", FmtToStr(func_name) + " is skipped since function" +
+            FmtToStr(func_name) + " is not existed!"});
         GELOGE(GE_PLGMGR_PATH_INVALID, "%s is skipped since function %s is not existed!", func_name.c_str(),
                func_name.c_str());
         is_valid = false;

ge/common/ge/tbe_plugin_manager.cc

@@ -37,6 +37,8 @@
 #include "graph/utils/type_utils.h"
 
 namespace ge {
+const int kBaseInt = 10;
+
 std::map<string, string> TBEPluginManager::options_ = {};
 
 // Get Singleton Instance
@@ -155,7 +157,7 @@ void TBEPluginManager::GetCustomOpPath(std::string &customop_path) {
   domi::FrameworkType type = domi::TENSORFLOW;
   auto it = options_.find(FRAMEWORK_TYPE);
   if (it != options_.end()) {
-    type = static_cast<domi::FrameworkType>(std::strtol(it->second.c_str(), nullptr, 10));
+    type = static_cast<domi::FrameworkType>(std::strtol(it->second.c_str(), nullptr, kBaseInt));
   }
   fmk_type = ge::TypeUtils::FmkTypeToSerialString(type);
   GELOGI("Framework type is %s.", fmk_type.c_str());

ge/common/ge_common.mk

@@ -7,6 +7,7 @@ GE_COMMON_LOCAL_SRC_FILES := \
     helper/om_file_helper.cc \
     helper/model_helper.cc \
     ../model/ge_model.cc \
+    ../model/ge_root_model.cc \
     auth/file_saver.cc \
     fp16_t.cc \
     math/fp16_math.cc \

ge/common/helper/model_helper.cc

@@ -32,6 +32,7 @@ using domi::ModelTaskDef;
 
 namespace {
 const int64_t kOriginalOmPartitionNum = 1;
+const uint32_t kStatiOmFileModelNum = 1;
 }
 
 
@@ -39,7 +40,7 @@ namespace ge {
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelHelper::~ModelHelper() { (void)ReleaseLocalModelData(); }
 
 Status ModelHelper::SaveModelPartition(std::shared_ptr<OmFileSaveHelper> &om_file_save_helper, ModelPartitionType type,
-                                       const uint8_t *data, size_t size) {
+                                       const uint8_t *data, size_t size, size_t model_index) {
   if (size < 1 || size > UINT32_MAX) {
     GELOGE(PARAM_INVALID, "Add model partition failed, partition size %zu invalid", size);
     if (size > UINT32_MAX) {
@@ -68,25 +69,16 @@ Status ModelHelper::SaveModelPartition(std::shared_ptr<OmFileSaveHelper> &om_fil
   partition_model.data = const_cast<uint8_t *>(data);
   partition_model.size = static_cast<uint32_t>(size);
   partition_model.type = type;
-  if (om_file_save_helper->AddPartition(partition_model) != SUCCESS) {
+  if (om_file_save_helper->AddPartition(partition_model, model_index) != SUCCESS) {
     GELOGE(PARAM_INVALID, "Add model partition failed, partition size %zu", size);
     return PARAM_INVALID;
   }
   return SUCCESS;
 }
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmModel(const GeModelPtr &ge_model,
-                                                                                   const SaveParam &save_param,
-                                                                                   const std::string &output_file,
-                                                                                   ModelBufferData& model) {
-  if (output_file.empty()) {
-    GELOGE(FAILED, "GraphBuilder SaveModel received invalid file name prefix");
-    return FAILED;
-  }
 
-  GE_IF_BOOL_EXEC(ge_model == nullptr, GELOGE(FAILED, "Ge_model is nullptr"); return FAILED);
-  std::shared_ptr<OmFileSaveHelper> om_file_save_helper = ge::MakeShared<OmFileSaveHelper>();
-  GE_CHECK_NOTNULL(om_file_save_helper);
+Status ModelHelper::SaveModelDef(std::shared_ptr<OmFileSaveHelper> &om_file_save_helper,
+                                 const GeModelPtr &ge_model, ge::Buffer &model_buffer, size_t model_index) {
   ModelPtr model_tmp = ge::MakeShared<ge::Model>(ge_model->GetName(), ge_model->GetPlatformVersion());
   if (model_tmp == nullptr) {
     GELOGE(FAILED, "Create Model %s Ptr failed", ge_model->GetName().c_str());
@@ -96,16 +88,21 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   model_tmp->SetVersion(ge_model->GetVersion());
   model_tmp->SetAttr(ge_model->MutableAttrMap());
 
-  ge::Buffer model_buffer;
+
   (void)model_tmp->Save(model_buffer);
   GELOGD("MODEL_DEF size is %zu", model_buffer.GetSize());
   if (model_buffer.GetSize() > 0) {
     if (SaveModelPartition(om_file_save_helper, ModelPartitionType::MODEL_DEF, model_buffer.GetData(),
-                           model_buffer.GetSize()) != SUCCESS) {
+                           model_buffer.GetSize(), model_index) != SUCCESS) {
       GELOGE(PARAM_INVALID, "Add model graph partition failed");
       return PARAM_INVALID;
     }
   }
+  return SUCCESS;
+}
+
+Status ModelHelper::SaveModelWeights(std::shared_ptr<OmFileSaveHelper> &om_file_save_helper,
+                                     const GeModelPtr &ge_model, size_t model_index) {
   auto ge_model_weight = ge_model->GetWeight();
   GELOGD("WEIGHTS_DATA size is %zu, %p", ge_model_weight.GetSize(), ge_model_weight.GetData());
   // weight is not necessary
@@ -113,31 +110,43 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
     GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
                                          ModelPartitionType::WEIGHTS_DATA,
                                          ge_model_weight.GetData(),
-                                         ge_model_weight.GetSize()), "Add weight partition failed");
+                                         ge_model_weight.GetSize(), model_index), "Add weight partition failed");
   }
+  return SUCCESS;
+}
 
+Status ModelHelper::SaveModelTbeKernel(std::shared_ptr<OmFileSaveHelper> &om_file_save_helper,
+                                       const GeModelPtr &ge_model, size_t model_index) {
   TBEKernelStore tbe_kernel_store = ge_model->GetTBEKernelStore();
   GELOGD("TBE_KERNELS size is %zu", tbe_kernel_store.DataSize());
   if (tbe_kernel_store.DataSize() > 0) {
-    GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
-                                         ModelPartitionType::TBE_KERNELS,
-                                         tbe_kernel_store.Data(),
-                                         tbe_kernel_store.DataSize()), "Add tbe kernel partition failed");
+    GE_CHK_STATUS_RET(
+        SaveModelPartition(om_file_save_helper, ModelPartitionType::TBE_KERNELS,
+                           ge_model->GetTBEKernelStore().Data(), ge_model->GetTBEKernelStore().DataSize(), 
+                           model_index), "Add tbe kernel partition failed");
   }
-
   // no need to check value, DATA->NetOutput
   (void)tbe_kernel_store.Load(tbe_kernel_store.Data(), tbe_kernel_store.DataSize());
 
+  return SUCCESS;
+}
+
+Status ModelHelper::SaveModelCustAICPU(std::shared_ptr<OmFileSaveHelper> &om_file_save_helper,
+                                       const GeModelPtr &ge_model, size_t model_index) {
   CustAICPUKernelStore cust_aicpu_kernel_store = ge_model->GetCustAICPUKernelStore();
   GELOGD("cust aicpu kernels size is %zu", cust_aicpu_kernel_store.DataSize());
   if (cust_aicpu_kernel_store.DataSize() > 0) {
     GE_CHK_STATUS_RET(SaveModelPartition(om_file_save_helper,
                                          ModelPartitionType::CUST_AICPU_KERNELS,
-                                         cust_aicpu_kernel_store.Data(),
-                                         cust_aicpu_kernel_store.DataSize()),
+                                         ge_model->GetCustAICPUKernelStore().Data(),
+                                         cust_aicpu_kernel_store.DataSize(), model_index),
                       "Add cust aicpu kernel partition failed");
   }
+  return SUCCESS;
+}
 
+Status ModelHelper::SaveModelTaskDef(std::shared_ptr<OmFileSaveHelper> &om_file_save_helper,
+                                     const GeModelPtr &ge_model, ge::Buffer &task_buffer, size_t model_index) {
   std::shared_ptr<ModelTaskDef> model_task_def = ge_model->GetModelTaskDefPtr();
   if (model_task_def == nullptr) {
     GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Create model task def ptr failed");
@@ -146,9 +155,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   size_t partition_task_size = model_task_def->ByteSizeLong();
   GE_IF_BOOL_EXEC(partition_task_size == 0 || partition_task_size > INT_MAX,
                   GELOGE(FAILED, "Model_def's byte size (%zu) is invalid!", partition_task_size);
-                  return FAILED);
+                      return FAILED);
 
-  ge::Buffer task_buffer(partition_task_size);
+  task_buffer = ge::Buffer(partition_task_size);
   if (task_buffer.GetSize() == 0) {
     GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Alloc model task def buffer failed");
     return ACL_ERROR_GE_MEMORY_ALLOCATION;
@@ -159,21 +168,28 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   GELOGD("TASK_INFO size is %zu", partition_task_size);
 
   if (SaveModelPartition(om_file_save_helper, ModelPartitionType::TASK_INFO, task_buffer.GetData(),
-                         partition_task_size) != SUCCESS) {
+                         partition_task_size, model_index) != SUCCESS) {
     GELOGE(PARAM_INVALID, "Add model task def partition failed");
     return PARAM_INVALID;
   }
+  return SUCCESS;
+}
+
+Status ModelHelper::SaveModelHeader(std::shared_ptr<OmFileSaveHelper> &om_file_save_helper,
+                                    const GeModelPtr &ge_model, size_t model_num) {
   // Save target/version to model_header
   ModelFileHeader &model_header = om_file_save_helper->GetModelFileHeader();
   model_header.platform_type = ge_model->GetPlatformType();
   model_header.om_ir_version = ge_model->GetVersion();
+  model_header.model_num = model_num;
   std::string platform_version = ge_model->GetPlatformVersion();
 
   errno_t err;
   err = memcpy_s(model_header.platform_version, PLATFORM_VERSION_LEN, platform_version.c_str(),
                  platform_version.size() + 1);
   if (err != EOK) {
-    GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "ModelHelper SaveModel failed while allocating memory for platform_version.");
+    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);
@@ -188,8 +204,142 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmMod
   }
   string model_name = reinterpret_cast<char *>(model_header.name);
   GELOGD("Model name save:%s", model_name.c_str());
+  return SUCCESS;
+}
+
+Status ModelHelper::SaveAllModelPartiton(std::shared_ptr<OmFileSaveHelper>& om_file_save_helper,
+                                         const GeModelPtr &ge_model, ge::Buffer &model_buffer,
+                                         ge::Buffer &task_buffer, size_t model_index) {
+  if (SaveModelDef(om_file_save_helper, ge_model, model_buffer, model_index) != SUCCESS) {
+    GELOGE(FAILED, "save model def failed");
+    return FAILED;
+  }
+
+  if (SaveModelWeights(om_file_save_helper, ge_model, model_index) != SUCCESS) {
+    GELOGE(FAILED, "save model weights failed");
+    return FAILED;
+  }
+
+  if (SaveModelTbeKernel(om_file_save_helper, ge_model, model_index) != SUCCESS) {
+    GELOGE(FAILED, "save model tbe kernel failed");
+    return FAILED;
+  }
+
+  if (SaveModelCustAICPU(om_file_save_helper, ge_model, model_index) != SUCCESS) {
+    GELOGE(FAILED, "save model cust ai cpu failed");
+    return FAILED;
+  }
+
+
+  if (SaveModelTaskDef(om_file_save_helper, ge_model, task_buffer, model_index) != SUCCESS) {
+    GELOGE(FAILED, "save task def failed");
+    return FAILED;
+  }
+  return SUCCESS;
+}
+
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmModel(const GeModelPtr &ge_model,
+                                                                                   const SaveParam &save_param,
+                                                                                   const std::string &output_file,
+                                                                                   ModelBufferData& model) {
+  if (output_file.empty()) {
+    GELOGE(FAILED, "GraphBuilder SaveModel received invalid file name prefix");
+    return FAILED;
+  }
 
-  Status ret = om_file_save_helper->SaveModel(save_param, output_file.c_str(), model, is_offline_);
+  GE_IF_BOOL_EXEC(ge_model == nullptr, GELOGE(FAILED, "Ge_model is nullptr"); return FAILED);
+  std::shared_ptr<OmFileSaveHelper> om_file_save_helper = ge::MakeShared<OmFileSaveHelper>();
+  GE_CHECK_NOTNULL(om_file_save_helper);
+  ge::Buffer model_buffer;
+  ge::Buffer task_buffer;
+
+  auto ret = SaveAllModelPartiton(om_file_save_helper, ge_model, model_buffer, task_buffer);
+  if (ret != SUCCESS) {
+    GELOGE(ret, "save all model partition failed");
+    return ret;
+  }
+
+  ret = SaveModelHeader(om_file_save_helper, ge_model);
+  if (ret != SUCCESS) {
+    GELOGE(ret, "save model header failed");
+    return ret;
+  }
+
+  ret = om_file_save_helper->SaveModel(save_param, output_file.c_str(), model, is_offline_);
+  if (ret != SUCCESS) {
+    GELOGE(FAILED, "OmFileSaveHelper SaveModel return fail.");
+    return ret;
+  }
+  return SUCCESS;
+}
+
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::SaveToOmRootModel(
+    const GeRootModelPtr &ge_root_model,
+    const SaveParam &save_param,
+    const std::string &output_file,
+    ModelBufferData& model,
+    bool is_unknown_shape) {
+
+  GE_CHECK_NOTNULL(ge_root_model);
+  GE_IF_BOOL_EXEC(ge_root_model == nullptr, GELOGE(FAILED, "Ge_root_model is nullptr"); return FAILED);
+
+  auto &name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
+  GE_IF_BOOL_EXEC(name_to_ge_model.empty(), GELOGE(FAILED, "Ge_root_model has no sub model"); return FAILED);
+  GE_IF_BOOL_EXEC(output_file.empty(),
+                  GELOGE(FAILED, "GraphBuilder SaveModel received invalid file name prefix");
+                  return FAILED);
+
+  if (!is_unknown_shape) {
+    auto &model_root = name_to_ge_model.begin()->second;
+    return SaveToOmModel(model_root, save_param, output_file, model);
+  }
+
+  std::shared_ptr<OmFileSaveHelper> om_file_save_helper = ge::MakeShared<OmFileSaveHelper>();
+  GE_CHECK_NOTNULL(om_file_save_helper);
+
+  auto &first_ge_model = name_to_ge_model.at(ge_root_model->GetRootGraph()->GetName());
+
+  // ge root model must be the first to be loaded
+  vector<string> model_names{ge_root_model->GetRootGraph()->GetName()};
+  for (auto &item : name_to_ge_model) {
+    if (item.first != model_names.front()) {
+      model_names.emplace_back(item.first);
+    }
+  }
+  
+  vector<ge::Buffer> model_buffers(model_names.size());
+  vector<ge::Buffer> task_buffers(model_names.size());
+
+  size_t cur_index = 0;
+
+  if (model_names.size() > 1) {
+    GELOGD("only save first model MODEL_DEF");
+    if (SaveModelDef(om_file_save_helper, first_ge_model, model_buffers[cur_index], cur_index) != SUCCESS) {
+      GELOGE(FAILED, "save model def failed");
+      return FAILED;
+    }
+    ++cur_index;
+  }
+
+  for (; cur_index < model_names.size(); ++cur_index) {
+    auto model_name = model_names[cur_index];
+    GELOGD("cur model %s index is %zu", model_name.c_str(), cur_index);
+    const GeModelPtr &ge_model = name_to_ge_model.at(model_name);
+    auto ret = SaveAllModelPartiton(om_file_save_helper, ge_model, model_buffers[cur_index],
+                                    task_buffers[cur_index], cur_index);
+    if (ret != SUCCESS) {
+      GELOGE(INTERNAL_ERROR, "Save model %s failed", model_name.c_str());
+      return INTERNAL_ERROR;
+    }
+  }
+
+  auto ret = SaveModelHeader(om_file_save_helper, first_ge_model, model_names.size());
+  if (ret != SUCCESS) {
+    GELOGE(INTERNAL_ERROR, "Save model %s header failed", first_ge_model->GetName().c_str());
+    return INTERNAL_ERROR;
+  }
+
+  ret = om_file_save_helper->SaveRootModel(save_param, output_file.c_str(), model, is_offline_);
   if (ret != SUCCESS) {
     GELOGE(FAILED, "OmFileSaveHelper SaveModel return fail.");
     return FAILED;
@@ -288,7 +438,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadModel(c
   }
 
   file_header_ = reinterpret_cast<ModelFileHeader *>(model_data.model_data);
-
   OmFileLoadHelper om_load_helper;
   status = om_load_helper.Init(model_addr_tmp_, model_len_tmp_);
   if (status != SUCCESS) {
@@ -310,7 +459,61 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadModel(c
     GELOGE(status, "GenerateGeModel failed");
     return status;
   }
+  GELOGD("in ModelHelper::LoadModel, is_assign_model_ is setted to true!");
+  is_assign_model_ = true;
+  return SUCCESS;
+}
+
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadRootModel(const ge::ModelData &model_data) {
+  if (model_data.model_data == nullptr || model_data.model_len == 0) {
+    GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "Model_data is nullptr, or model_data_size is 0");
+    return GE_EXEC_MODEL_DATA_SIZE_INVALID;
+  }
+
+  if (is_assign_model_) {
+    GELOGE(GE_EXEC_LOAD_MODEL_REPEATED, "Model helper has already loaded!");
+    return GE_EXEC_LOAD_MODEL_REPEATED;
+  }
 
+  if (ReleaseLocalModelData() != SUCCESS) {
+    GELOGE(INTERNAL_ERROR, "ReleaseLocalModelData failed.");
+    return INTERNAL_ERROR;
+  }
+
+  Status status = ge::DavinciModelParser::ParseModelContent(model_data, model_addr_tmp_, model_len_tmp_);
+  if (status != SUCCESS) {
+    GELOGE(status, "Parse model content failed!");
+    return status;
+  }
+
+  file_header_ = reinterpret_cast<ModelFileHeader *>(model_data.model_data);
+
+  //model verison 1.0 file header does not have model_num member
+  is_unknown_shape_model_ = file_header_->version >= ge::MODEL_VERSION &&
+                            file_header_->model_num > kStatiOmFileModelNum;
+  GELOGD("cur om model is ge root model or no %d, model version %zu", is_unknown_shape_model_, file_header_->version);
+
+  OmFileLoadHelper om_load_helper;
+  if (is_unknown_shape_model_) {
+    auto model_num = file_header_->model_num;
+    status = om_load_helper.Init(model_addr_tmp_, model_len_tmp_, model_num);
+  } else {
+    status = om_load_helper.Init(model_addr_tmp_, model_len_tmp_);
+  }
+  if (status != SUCCESS) {
+    GELOGE(status, "Om_load_helper init failed");
+    model_addr_tmp_ = nullptr;
+    return status;
+  }
+  // Encrypt model need to del temp model/no encrypt model don't need to del model
+  model_addr_tmp_ = nullptr;
+
+  status = GenerateGeRootModel(om_load_helper);
+  if (status != SUCCESS) {
+    GELOGE(status, "GenerateGeRootModel failed");
+    return status;
+  }
+  GELOGD("in ModelHelper::LoadRootModel, is_assign_model_ is setted to true!");
   is_assign_model_ = true;
   return SUCCESS;
 }
@@ -341,6 +544,61 @@ Status ModelHelper::GenerateGeModel(OmFileLoadHelper &om_load_helper) {
   return SUCCESS;
 }
 
+Status ModelHelper::GenerateGeRootModel(OmFileLoadHelper &om_load_helper) {
+  GELOGD("Begin to generate ge root model");
+  root_model_ = ge::MakeShared<ge::GeRootModel>();
+  GE_CHECK_NOTNULL(root_model_);
+  if (!is_unknown_shape_model_) {
+    if (GenerateGeModel(om_load_helper) != SUCCESS) {
+      GELOGE(FAILED, "GenerateGeModel failed");
+      return FAILED;
+    }
+    GE_CHECK_NOTNULL(model_);
+    root_model_->SetRootGraph(GraphUtils::GetComputeGraph(model_->GetGraph()));
+    return SUCCESS;
+  }
+
+  bool is_first_model = true;
+  for (size_t mode_index = 0;  mode_index < file_header_->model_num; ++mode_index) {
+    GeModelPtr cur_model = ge::MakeShared<ge::GeModel>();
+    Status ret = LoadModelData(om_load_helper, cur_model, mode_index);
+    if (ret != SUCCESS) {
+      return GE_EXEC_LOAD_MODEL_PARTITION_FAILED;
+    }
+
+    if (is_first_model) {
+      is_first_model = false;
+      root_model_->SetRootGraph(GraphUtils::GetComputeGraph(cur_model->GetGraph()));
+      root_model_->SetModelId(cur_model->GetModelId());
+      model_ = cur_model;
+      continue;
+    }
+
+    ret = LoadWeights(om_load_helper, cur_model, mode_index);
+    if (ret != SUCCESS) {
+      return GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED;
+    }
+
+    ret = LoadTBEKernelStore(om_load_helper, cur_model, mode_index);
+    if (ret != SUCCESS) {
+      return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED;
+    }
+
+    ret = LoadCustAICPUKernelStore(om_load_helper, cur_model, mode_index);
+    if (ret != SUCCESS) {
+      return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED;
+    }
+
+    ret = LoadTask(om_load_helper, cur_model, mode_index);
+    if (ret != SUCCESS) {
+      return GE_EXEC_LOAD_TASK_PARTITION_FAILED;
+    }
+    root_model_->SetSubgraphInstanceNameToModel(cur_model->GetName(), cur_model);
+  }
+
+  return SUCCESS;
+}
+
 Status ModelHelper::LoadModelData(OmFileLoadHelper &om_load_helper) {
   ModelPartition partition_model_def;
   // no need to check value, DATA->NetOutput
@@ -366,6 +624,28 @@ void ModelHelper::SetModelToGeModel(ge::Model &model) {
   model_->SetAttr(model.MutableAttrMap());
 }
 
+Status ModelHelper::LoadModelData(OmFileLoadHelper &om_load_helper, GeModelPtr &cur_model, size_t mode_index) {
+  ModelPartition partition_model_def;
+  // no need to check value, DATA->NetOutput
+  om_load_helper.GetModelPartition(ModelPartitionType::MODEL_DEF, partition_model_def, mode_index);
+  GELOGD("Model_def partition addr:%p,size:%u", partition_model_def.data, partition_model_def.size);
+
+  ge::Model model;
+  if (ge::Model::Load(partition_model_def.data, partition_model_def.size, model) != SUCCESS) {
+    GELOGE(INTERNAL_ERROR, "Load model failed.");
+    return INTERNAL_ERROR;
+  }
+
+  cur_model->SetGraph(model.GetGraph());
+  cur_model->SetName(model.GetName());
+  cur_model->SetVersion(model.GetVersion());
+  cur_model->SetPlatformVersion(model.GetPlatformVersion());
+  cur_model->SetAttr(model.MutableAttrMap());
+
+  return SUCCESS;
+}
+
+
 Status ModelHelper::LoadWeights(OmFileLoadHelper &om_load_helper) {
   ModelPartition partition;
   if (om_load_helper.GetModelPartition(ModelPartitionType::WEIGHTS_DATA, partition) != SUCCESS) {
@@ -379,6 +659,19 @@ Status ModelHelper::LoadWeights(OmFileLoadHelper &om_load_helper) {
   return SUCCESS;
 }
 
+Status ModelHelper::LoadWeights(OmFileLoadHelper &om_load_helper, GeModelPtr &cur_model, size_t mode_index) {
+  ModelPartition partition;
+  if (om_load_helper.GetModelPartition(ModelPartitionType::WEIGHTS_DATA, partition, mode_index) != SUCCESS) {
+    GELOGE(FAILED, "Get weight model partition failed.");
+    return FAILED;
+  }
+  ge::Buffer weight = ge::Buffer::CopyFrom(partition.data, partition.size);
+  cur_model->SetWeight(weight);
+
+  GELOGD("GetWeight size:%u", partition.size);
+  return SUCCESS;
+}
+
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadTask(OmFileLoadHelper &om_load_helper) {
   ModelPartition task_partition;
   if (om_load_helper.GetModelPartition(ModelPartitionType::TASK_INFO, task_partition) != SUCCESS) {
@@ -398,6 +691,27 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadTask(Om
   return SUCCESS;
 }
 
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadTask(OmFileLoadHelper &om_load_helper,
+                                                                              GeModelPtr &cur_model,
+                                                                              size_t mode_index) {
+  ModelPartition task_partition;
+  if (om_load_helper.GetModelPartition(ModelPartitionType::TASK_INFO, task_partition, mode_index) != SUCCESS) {
+    GELOGE(FAILED, "Get task model partition failed.");
+    return FAILED;
+  }
+  std::shared_ptr<ModelTaskDef> task = ge::MakeShared<ModelTaskDef>();
+  GE_CHECK_NOTNULL(task);
+  if (task_partition.size != 0) {
+    if (!ReadProtoFromArray(task_partition.data, task_partition.size, task.get())) {
+      GELOGE(INTERNAL_ERROR, "ReadProtoFromArray failed.");
+      return INTERNAL_ERROR;
+    }
+    GELOGD("TASK_INFO op_size:%zu, stream_num:%u", task->op().size(), task->stream_num());
+  }
+  cur_model->SetModelTaskDef(task);
+  return SUCCESS;
+}
+
 Status ModelHelper::LoadTBEKernelStore(OmFileLoadHelper &om_load_helper) {
   // Load tbe kernels
   ModelPartition partition_kernel_def;
@@ -414,6 +728,23 @@ Status ModelHelper::LoadTBEKernelStore(OmFileLoadHelper &om_load_helper) {
   return SUCCESS;
 }
 
+Status ModelHelper::LoadTBEKernelStore(OmFileLoadHelper &om_load_helper, GeModelPtr &cur_model, size_t mode_index) {
+  // Load tbe kernels
+  ModelPartition partition_kernel_def;
+  TBEKernelStore kernel_store;
+  if (om_load_helper.GetModelPartition(ModelPartitionType::TBE_KERNELS, partition_kernel_def, mode_index) ==
+      SUCCESS) {
+    GELOGD("Kernels partition size:%u", partition_kernel_def.size);
+    if (kernel_store.Load(partition_kernel_def.data, partition_kernel_def.size)) {
+      GELOGD("Load tbe kernels success");
+    } else {
+      GELOGW("Load tbe kernels failed");
+    }
+  }
+  cur_model->SetTBEKernelStore(kernel_store);
+  return SUCCESS;
+}
+
 Status ModelHelper::LoadCustAICPUKernelStore(OmFileLoadHelper &om_load_helper) {
   // Load cust aicpu kernels
   ModelPartition partition_kernel_def;
@@ -421,19 +752,39 @@ Status ModelHelper::LoadCustAICPUKernelStore(OmFileLoadHelper &om_load_helper) {
   if (om_load_helper.GetModelPartition(ModelPartitionType::CUST_AICPU_KERNELS, partition_kernel_def) == SUCCESS) {
     GELOGD("Kernels partition size:%u", partition_kernel_def.size);
     if (kernel_store.Load(partition_kernel_def.data, partition_kernel_def.size)) {
-      GELOGI("Load cust aicpu kernels success");
+      GELOGD("Load cust aicpu kernels success");
+    } else {
+      GELOGW("Load cust aicpu kernels failed");
     }
   }
   model_->SetCustAICPUKernelStore(kernel_store);
   return SUCCESS;
 }
 
+Status ModelHelper::LoadCustAICPUKernelStore(OmFileLoadHelper &om_load_helper,
+                                             GeModelPtr &cur_model, size_t mode_index) {
+  // Load cust aicpu kernels
+  ModelPartition partition_kernel_def;
+  CustAICPUKernelStore kernel_store;
+  if (om_load_helper.GetModelPartition(ModelPartitionType::CUST_AICPU_KERNELS, partition_kernel_def, mode_index)
+      == SUCCESS) {
+    GELOGD("Kernels partition size:%u", partition_kernel_def.size);
+    if (kernel_store.Load(partition_kernel_def.data, partition_kernel_def.size)) {
+      GELOGD("Load cust aicpu kernels success");
+    } else {
+      GELOGW("Load cust aicpu kernels failed");
+    }
+  }
+  cur_model->SetCustAICPUKernelStore(kernel_store);
+  return SUCCESS;
+}
+
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY GeModelPtr ModelHelper::GetGeModel() {
   if (model_ != nullptr) {
     return model_;
   }
 
-  GELOGI("Model has not been loaded!");
+  GELOGD("Model has not been loaded!");
   std::shared_ptr<ge::GeModel> out_model = ge::MakeShared<ge::GeModel>();
   if (out_model == nullptr) {
     return nullptr;
@@ -441,6 +792,20 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY GeModelPtr ModelHelper::GetGeMo
   return out_model;
 }
 
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY GeRootModelPtr ModelHelper::GetGeRootModel() {
+  if (root_model_ != nullptr) {
+    return root_model_;
+  }
+
+  GELOGD("Model has not been loaded!");
+  std::shared_ptr<ge::GeRootModel> out_model = ge::MakeShared<ge::GeRootModel>();
+  if (out_model == nullptr) {
+    return nullptr;
+  }
+  return out_model;
+}
+
+
 Status ModelHelper::ReleaseLocalModelData() noexcept {
   Status result = SUCCESS;
   if (model_addr_tmp_ != nullptr) {

ge/common/helper/om_file_helper.cc

@@ -52,6 +52,17 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status OmFileLoadHelper::Init(u
   return SUCCESS;
 }
 
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status OmFileLoadHelper::Init(uint8_t *model_data,
+                                                                               uint32_t model_data_size,
+                                                                               uint32_t model_num) {
+  Status status = LoadModelPartitionTable(model_data, model_data_size, model_num);
+  if (status != SUCCESS) {
+    return status;
+  }
+  is_inited_ = true;
+  return SUCCESS;
+}
+
 // Use both
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status OmFileLoadHelper::GetModelPartition(ModelPartitionType type,
                                                                                             ModelPartition &partition) {
@@ -79,6 +90,37 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status OmFileLoadHelper::GetMod
   return SUCCESS;
 }
 
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status OmFileLoadHelper::GetModelPartition(ModelPartitionType type,
+                                                                                            ModelPartition &partition,
+                                                                                            size_t model_index) {
+  if (!is_inited_) {
+    GELOGE(PARAM_INVALID, "OmFileLoadHelper has not been initialized!");
+    return PARAM_INVALID;
+  }
+  if (model_index >= model_contexts_.size()) {
+    GELOGE(PARAM_INVALID, "cur index : %zu, model_contexts size:%zu", model_index, model_contexts_.size());
+    return PARAM_INVALID;
+  }
+  auto &cur_ctx = model_contexts_[model_index];
+  bool found = false;
+  for (ModelPartition &part : cur_ctx.partition_datas_) {
+    if (part.type == type) {
+      partition = part;
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    if (type != ModelPartitionType::TBE_KERNELS && type != ModelPartitionType::WEIGHTS_DATA &&
+        type != ModelPartitionType::CUST_AICPU_KERNELS) {
+      GELOGE(FAILED, "GetModelPartition:type:%d is not in partition_datas!", static_cast<int>(type));
+      return FAILED;
+    }
+  }
+  return SUCCESS;
+}
+
 Status OmFileLoadHelper::CheckModelValid(const ge::ModelData &model) const {
   // Parameter validity check
   if (model.model_data == nullptr) {
@@ -138,7 +180,8 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint
     context_.partition_datas_.push_back(partition);
 
     if (partition.size > model_data_size || mem_offset > model_data_size - partition.size) {
-      GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID, "The partition size %zu is greater than the model data size %u.",
+      GELOGE(ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID,
+             "The partition size %zu is greater than the model data size %u.",
              partition.size + mem_offset, model_data_size);
       return ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID;
     }
@@ -148,6 +191,61 @@ Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, const uint
   return SUCCESS;
 }
 
+Status OmFileLoadHelper::LoadModelPartitionTable(uint8_t *model_data, uint32_t model_data_size, uint32_t model_num) {
+  if (model_data == nullptr) {
+    GELOGE(PARAM_INVALID, "Param model_data must not be null!");
+    return PARAM_INVALID;
+  }
+
+  uint32_t cur_offset = 0;
+  for (uint32_t index = 0; index < model_num; ++index) {
+    // Init partition table
+    auto partition_table = reinterpret_cast<ModelPartitionTable *>(model_data + cur_offset);
+    size_t partition_table_size = SIZE_OF_MODEL_PARTITION_TABLE(*partition_table);
+    cur_offset += partition_table_size;
+    GELOGD("Cur model index %zu: ModelPartitionTable num :%u, "
+           "ModelFileHeader length :%zu, ModelPartitionTable length :%zu",
+           index, partition_table->num, sizeof(ModelFileHeader), partition_table_size);
+    if (model_data_size <= cur_offset) {
+      GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "invalid model data, partition_table->num:%u, model data size %u",
+             partition_table->num, model_data_size);
+      return GE_EXEC_MODEL_DATA_SIZE_INVALID;
+    }
+
+    for (uint32_t i = 0; i < partition_table->num; i++) {
+      ModelPartition partition;
+      partition.size = partition_table->partition[i].mem_size;
+      partition.data = model_data + cur_offset;
+      partition.type = partition_table->partition[i].type;
+      if (index >= model_contexts_.size()) {
+        if (index != model_contexts_.size()) {
+          GELOGE(FAILED, "cur index is %zu make model_contexts_ overflow", index);
+          return FAILED;
+        }
+
+        OmFileContext tmp_ctx;
+        tmp_ctx.partition_datas_.push_back(partition);
+        model_contexts_.push_back(tmp_ctx);
+      } else {
+        model_contexts_[index].partition_datas_.push_back(partition);
+      }
+
+      if (partition.size > model_data_size || cur_offset > model_data_size - partition.size) {
+        GELOGE(GE_EXEC_MODEL_DATA_SIZE_INVALID, "The partition size %zu is greater than the model data size %u.",
+               partition.size + cur_offset, model_data_size);
+        return GE_EXEC_MODEL_DATA_SIZE_INVALID;
+      }
+      cur_offset += partition.size;
+      GELOGD("Partition, type:%d, size:%u, model_index:%zu", static_cast<int>(partition.type), partition.size, index);
+    }
+  }
+  if (cur_offset != model_data_size) {
+    GELOGE(FAILED, "do not get the complete model, read end offset:%zu, all size:%zu", cur_offset, model_data_size);
+    return FAILED;
+  }
+  return SUCCESS;
+}
+
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY const std::vector<ModelPartition>
   &OmFileSaveHelper::GetModelPartitions() const {
   return context_.partition_datas_;
@@ -172,6 +270,28 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelPartitionTable *OmFileSave
   return partition_table;
 }
 
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ModelPartitionTable *OmFileSaveHelper::GetPartitionTable(
+    size_t cur_ctx_index) {
+  auto &cur_ctx = model_contexts_[cur_ctx_index];
+  auto partition_size = static_cast<uint32_t>(cur_ctx.partition_datas_.size());
+  // Build ModelPartitionTable, flex array
+  cur_ctx.partition_table_.clear();
+  cur_ctx.partition_table_.resize(sizeof(ModelPartitionTable) + sizeof(ModelPartitionMemInfo) * partition_size, 0);
+
+  auto partition_table = reinterpret_cast<ModelPartitionTable *>(cur_ctx.partition_table_.data());
+  partition_table->num = partition_size;
+
+  uint32_t mem_offset = 0;
+  for (uint32_t i = 0; i < partition_size; i++) {
+    ModelPartition partition = cur_ctx.partition_datas_[i];
+    partition_table->partition[i] = {partition.type, mem_offset, partition.size};
+    mem_offset += partition.size;
+    GELOGD("Partition, type:%d, size:%u", static_cast<int>(partition.type), partition.size);
+  }
+  return partition_table;
+}
+
+
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status OmFileSaveHelper::AddPartition(ModelPartition &partition) {
   if (ge::CheckUint32AddOverflow(context_.model_data_len_, partition.size) != SUCCESS) {
     GELOGE(FAILED, "UINT32 %u and %u addition can result in overflow!", context_.model_data_len_, partition.size);
@@ -182,6 +302,27 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status OmFileSaveHelper::AddPar
   return SUCCESS;
 }
 
+Status OmFileSaveHelper::AddPartition(ModelPartition &partition, size_t cur_index) {
+  if (ge::CheckUint32AddOverflow(context_.model_data_len_, partition.size) != SUCCESS) {
+    GELOGE(FAILED, "UINT32 %u and %u addition can result in overflow!", context_.model_data_len_, partition.size);
+    return FAILED;
+  }
+  if (cur_index >= model_contexts_.size()) {
+    if (cur_index != model_contexts_.size()) {
+      GELOGE(FAILED, "cur index is %zu make model_contexts_ overflow", cur_index);
+      return FAILED;
+    }
+    OmFileContext tmp_ctx;
+    tmp_ctx.model_data_len_ += partition.size;
+    tmp_ctx.partition_datas_.push_back(partition);
+    model_contexts_.push_back(tmp_ctx);
+  } else {
+    model_contexts_[cur_index].model_data_len_ += partition.size;
+    model_contexts_[cur_index].partition_datas_.push_back(partition);
+  }
+  return SUCCESS;
+}
+
 Status OmFileSaveHelper::SaveModel(const SaveParam &save_param, const char *output_file, ModelBufferData &model,
                                    bool is_offline) {
   (void)save_param.cert_file;
@@ -198,6 +339,10 @@ Status OmFileSaveHelper::SaveModel(const SaveParam &save_param, const char *outp
 
 Status OmFileSaveHelper::SaveModelToFile(const char *output_file, ModelBufferData &model, bool is_offline) {
 #if !defined(NONSUPPORT_SAVE_TO_FILE)
+  if (context_.partition_datas_.empty()) {
+    GE_CHK_BOOL_EXEC(!model_contexts_.empty(), return FAILED, "mode contexts empty");
+    context_ = model_contexts_.front();
+  }
   uint32_t model_data_len = context_.model_data_len_;
   if (model_data_len == 0) {
     GELOGE(domi::PARAM_INVALID, "Model data len error! should not be 0");
@@ -231,4 +376,53 @@ Status OmFileSaveHelper::SaveModelToFile(const char *output_file, ModelBufferDat
   return SUCCESS;
 #endif
 }
+
+Status OmFileSaveHelper::SaveRootModel(const SaveParam &save_param, const char *output_file,
+                                       ModelBufferData &model, bool is_offline) {
+  (void)save_param.cert_file;
+  (void)save_param.ek_file;
+  (void)save_param.encode_mode;
+  (void)save_param.hw_key_file;
+  (void)save_param.pri_key_file;
+
+#if !defined(NONSUPPORT_SAVE_TO_FILE)
+  vector<ModelPartitionTable *> model_partition_tabels;
+  vector<vector<ModelPartition>> all_model_partitions;
+  for (size_t ctx_index = 0; ctx_index < model_contexts_.size(); ++ctx_index) {
+    auto &cur_ctx = model_contexts_[ctx_index];
+    uint32_t cur_model_data_len = cur_ctx.model_data_len_;
+    if (cur_model_data_len == 0) {
+      GELOGE(domi::PARAM_INVALID, "Model data len error! should not be 0");
+      return domi::PARAM_INVALID;
+    }
+
+    auto tmp_table = GetPartitionTable(ctx_index);
+    if (tmp_table == nullptr) {
+      GELOGE(ge::GE_GRAPH_SAVE_FAILED, "SaveModelToFile execute failed: partition_table is NULL.");
+      return ge::GE_GRAPH_SAVE_FAILED;
+    }
+    uint32_t size_of_table = SIZE_OF_MODEL_PARTITION_TABLE(*tmp_table);
+    FMK_UINT32_ADDCHECK(size_of_table, cur_model_data_len)
+    FMK_UINT32_ADDCHECK(size_of_table + cur_model_data_len, model_header_.length)
+    model_header_.length += size_of_table + cur_model_data_len;
+    model_partition_tabels.push_back(tmp_table);
+    all_model_partitions.push_back(cur_ctx.partition_datas_);
+    GELOGD("sizeof(ModelPartitionTable):%u, cur_model_data_len:%u, cur_context_index:%zu",
+           size_of_table, cur_model_data_len, ctx_index);
+  }
+  Status ret;
+  if (is_offline) {
+    ret = FileSaver::SaveToFile(output_file, model_header_, model_partition_tabels, all_model_partitions);
+  } else {
+    GELOGW("do not support save ge root model to buff now");
+    return FAILED;
+  }
+  if (ret == SUCCESS) {
+    GELOGD("Save model success without encrypt.");
+  }
+  return ret;
+#else
+  return SUCCESS;
+#endif
+}
 }  // namespace ge

ge/common/op/ge_op_utils.cc

@@ -357,7 +357,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void OpUtils::TransDataHWCK2KCH
   const char *w_data = (const char *)input;
 
   int64_t count = h * w * c * k;
-  GE_IF_BOOL_EXEC(count <= 0, GELOGW("Count value must be greater than 0, but count = %ld", count); return );
+  GE_IF_BOOL_EXEC(count <= 0, GELOGW("Count value must be greater than 0, but count = %ld", count); return);
   float *buf = new (std::nothrow) float[count]();
   GE_RT_VOID_CHECK_NOTNULL(buf);
   float *src_buff = nullptr;

ge/common/profiling/ge_profiling.cc

@@ -0,0 +1,199 @@
+/**
+ * Copyright 2020 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "common/profiling/ge_profiling.h"
+#include "runtime/base.h"
+#include "common/profiling/profiling_manager.h"
+#include "framework/common/debug/ge_log.h"
+#include "framework/common/debug/log.h"
+#include "graph/load/graph_loader.h"
+#include "init/gelib.h"
+#include "framework/common/ge_inner_error_codes.h"
+
+namespace {
+const uint32_t kDeviceListIndex = 3;
+const std::string kDeviceNums = "devNums";
+const std::string kDeviceIdList = "devIdList";
+const std::string kProfilingInit = "prof_init";
+const std::string kProfilingFinalize = "prof_finalize";
+const std::string kProfilingStart = "prof_start";
+const std::string kProfilingStop = "prof_stop";
+const std::string kProfModelSubscribe = "prof_model_subscribe";
+const std::string kProfModelUnsubscribe = "prof_model_cancel_subscribe";
+const std::string kRtSetDeviceRegName = "profiling";
+
+const std::map<ProfCommandHandleType, std::string> kProfCommandTypeMap = {
+    {kProfCommandhandleInit, kProfilingInit},
+    {kProfCommandhandleStart, kProfilingStart},
+    {kProfCommandhandleStop, kProfilingStop},
+    {kProfCommandhandleFinalize, kProfilingFinalize},
+    {kProfCommandhandleModelSubscribe, kProfModelSubscribe},
+    {kProfCommandhandleModelUnsubscribe, kProfModelUnsubscribe}};
+}  // namespace
+
+bool TransProfConfigToParam(const ProfCommandHandleData &profCommand, vector<string> &prof_config_params) {
+  prof_config_params.clear();
+  prof_config_params.emplace_back(kDeviceNums);
+  prof_config_params.emplace_back(std::to_string(profCommand.devNums));
+  prof_config_params.emplace_back(kDeviceIdList);
+  std::string devID = "";
+  if (profCommand.devNums == 0) {
+    GELOGW("The device num is invalid.");
+    return false;
+  }
+  for (uint32_t i = 0; i < profCommand.devNums; i++) {
+    devID.append(std::to_string(profCommand.devIdList[i]));
+    if (i != profCommand.devNums - 1) {
+      devID.append(",");
+    }
+  }
+
+  prof_config_params.push_back(devID);
+  return true;
+}
+
+bool isProfConfigValid(const uint32_t *deviceid_list, uint32_t device_nums) {
+  if (deviceid_list == nullptr) {
+    GELOGE(ge::PARAM_INVALID, "deviceIdList is nullptr");
+    return false;
+  }
+  if (device_nums == 0 || device_nums > MAX_DEV_NUM) {
+    GELOGE(ge::PARAM_INVALID, "The device nums: %u is invalid.", device_nums);
+    return false;
+  }
+
+  // real device num
+  int32_t dev_count = 0;
+  rtError_t rt_err = rtGetDeviceCount(&dev_count);
+  if (rt_err != RT_ERROR_NONE) {
+    GELOGE(ge::INTERNAL_ERROR, "Get the Device count fail.");
+    return false;
+  }
+
+  if (device_nums > static_cast<uint32_t>(dev_count)) {
+    GELOGE(ge::PARAM_INVALID, "Device num(%u) is not in range 1 ~ %d.", device_nums, dev_count);
+    return false;
+  }
+
+  std::unordered_set<uint32_t> record;
+  for (size_t i = 0; i < device_nums; ++i) {
+    uint32_t dev_id = deviceid_list[i];
+    if (dev_id >= static_cast<uint32_t>(dev_count)) {
+      GELOGE(ge::PARAM_INVALID, "Device id %u is not in range 0 ~ %d(exclude %d)", dev_id, dev_count, dev_count);
+      return false;
+    }
+    if (record.count(dev_id) > 0) {
+      GELOGE(ge::PARAM_INVALID, "Device id %u is duplicatedly set", dev_id);
+      return false;
+    }
+    record.insert(dev_id);
+  }
+  return true;
+}
+
+ge::Status RegProfCtrlCallback(MsprofCtrlCallback func) {
+  if (func == nullptr) {
+    GELOGE(ge::PARAM_INVALID, "Msprof ctrl callback is nullptr.");
+    return ge::PARAM_INVALID;
+  }
+  if (ge::ProfilingManager::Instance().GetMsprofCallback().msprofCtrlCallback != nullptr) {
+    GELOGW("Msprof ctrl callback is exist, just ignore it.");
+  } else {
+    GELOGI("GE register Msprof ctrl callback.");
+    ge::ProfilingManager::Instance().SetMsprofCtrlCallback(func);
+  }
+  return ge::SUCCESS;
+}
+
+ge::Status RegProfSetDeviceCallback(MsprofSetDeviceCallback func) {
+  if (func == nullptr) {
+    GELOGE(ge::PARAM_INVALID, "MsprofSetDeviceCallback callback is nullptr.");
+    return ge::PARAM_INVALID;
+  }
+  // Pass MsprofSetDeviceCallback to runtime
+  GELOGI("GE pass setdevice callback to runtime.");
+  ge::Status rt_ret = rtRegDeviceStateCallback(kRtSetDeviceRegName.c_str(), static_cast<rtDeviceStateCallback>(func));
+  if (rt_ret != ge::SUCCESS) {
+    GELOGE(rt_ret, "Pass MsprofSetDeviceCallback to runtime failed!");
+    return rt_ret;
+  }
+  return ge::SUCCESS;
+}
+
+ge::Status RegProfReporterCallback(MsprofReporterCallback func) {
+  if (func == nullptr) {
+    GELOGE(ge::PARAM_INVALID, "MsprofReporterCallback callback is nullptr.");
+    return ge::PARAM_INVALID;
+  }
+  if (ge::ProfilingManager::Instance().GetMsprofCallback().msprofReporterCallback != nullptr) {
+    GELOGW("Msprof reporter callback is exist, just ignore it.");
+  } else {
+    GELOGI("GE register Msprof reporter callback.");
+    ge::ProfilingManager::Instance().SetMsprofReporterCallback(func);
+    // Pass MsprofReporterCallback to runtime
+    ge::Status rt_ret = rtSetMsprofReporterCallback(func);
+    if (rt_ret != ge::SUCCESS) {
+      GELOGE(rt_ret, "Pass MsprofReporterCallback to runtime failed!!");
+      return rt_ret;
+    }
+    // Pass MsprofReporterCallback to hccl
+  }
+  return ge::SUCCESS;
+}
+
+ge::Status ProfCommandHandle(ProfCommandHandleType type, void *data, uint32_t len) {
+  if (type != kProfCommandhandleFinalize) {
+    GE_CHECK_NOTNULL(data);
+  }
+  ProfCommandHandleData *prof_config_param = (ProfCommandHandleData *)data;
+  auto iter = kProfCommandTypeMap.find(type);
+  if (iter == kProfCommandTypeMap.end()) {
+    GELOGW("The prof comand type is invalid.");
+    return ge::PARAM_INVALID;
+  }
+  std::vector<string> prof_params;
+  if (type == kProfCommandhandleStart || type == kProfCommandhandleStop) {
+    if (!isProfConfigValid(prof_config_param->devIdList, prof_config_param->devNums)) {
+      return ge::FAILED;
+    }
+  
+    if (!TransProfConfigToParam(*prof_config_param, prof_params)) {
+      GELOGE(ge::PARAM_INVALID, "Transfer profilerConfig to string vector failed");
+      return ge::PARAM_INVALID;
+    }
+  }
+  ge::GraphLoader graph_loader;
+  ge::Command command;
+  command.cmd_params.clear();
+  command.cmd_type = iter->second;
+  command.cmd_params = prof_params;
+  if (type != kProfCommandhandleFinalize) {
+    command.module_index = prof_config_param->profSwitch;
+  }
+  GELOGI("GE commandhandle execute, Command Type: %d, data type config: 0x%llx", type, command.module_index);
+  if (type == kProfCommandhandleStart || type == kProfCommandhandleStop) {
+    GELOGI("Profiling device nums:%s , deviceID:[%s]", prof_params[0].c_str(), prof_params[kDeviceListIndex].c_str());
+  }
+  ge::Status ret = graph_loader.CommandHandle(command);
+  if (ret != ge::SUCCESS) {
+    GELOGE(ret, "Handle profiling command failed");
+    return ge::FAILED;
+  }
+
+  GELOGI("Successfully execute profiling command type: %d, command 0x%llx.", type, command.module_index);
+  return ge::SUCCESS;
+}
+

ge/common/profiling/ge_runner_profiling.cc

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2020 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "common/profiling/ge_runner_profiling.h"
+#include "init/gelib.h"
+
+bool IsInitialize() {
+  std::shared_ptr<ge::GELib> instance_ptr = ge::GELib::GetInstance();
+  if (instance_ptr == nullptr || instance_ptr->InitFlag() == false) {
+    return false;
+  }
+  return true;
+}

ge/common/profiling/profiling_manager.cc

@@ -24,16 +24,9 @@
 #include "graph/load/new_model_manager/davinci_model.h"
 
 namespace {
-const char *const kJobID = "jobID";
-const char *const kDeviceID = "deviceID";
-const char *const kStartCfg = "startCfg";
-const char *const kFeatures = "features";
-const char *const kConf = "conf";
-const char *const kEvents = "events";
-const char *const kAiCoreEvents = "ai_core_events";
-const char *const kName = "name";
-const char *const kTraceID = "traceId";
-const char *const kProfDir = "resultPath";
+const char *const kTrainingTrace = "training_trace";
+const char *const kFpPoint = "fp_point";
+const char *const kBpPoint = "bp_point";
 const size_t kReportMaxLen = 2048;
 const int32_t kMaxDeviceNum = 256;
 const std::string kConfigNumsdev = "devNums";
@@ -45,7 +38,13 @@ const std::string kProfModelUnsubscribe = "prof_model_cancel_subscribe";
 }  // namespace
 
 namespace ge {
-ProfilingManager::ProfilingManager() : subscribe_count_(0) {}
+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;
+}
 
 ProfilingManager::~ProfilingManager() {}
 
@@ -58,44 +57,29 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ge::Status ProfilingManager::In
 #ifdef DAVINCI_SUPPORT_PROFILING
   vector<int32_t>().swap(device_id_);
   subscribe_count_ = 0;
-  job_id_ = options.job_id;
-
-  GELOGI("ProfilingManager::Init  job_id:%s", job_id_.c_str());
-
+  GELOGI("ProfilingManager::Init  job_id:%s", options.job_id.c_str());
 
-
-  Status ret;
-  if (!recv_profiling_config_.empty()) {
-    GELOGI("Profiling json config from acl:%s", recv_profiling_config_.c_str());
-    ret = InitFromAclCfg(recv_profiling_config_);
-  } else {
-    ret = InitFromOptions(options);
-    if (ret == SUCCESS && is_load_profiling_) {
-      device_id_.push_back(options.device_id);
-    }
-  }
+  struct MsprofGeOptions prof_conf = {{ 0 }};
+  Status ret = InitFromOptions(options, prof_conf);
   if (ret != SUCCESS) {
     GELOGE(ret, "Failed to init profiling.");
     return ret;
   }
 
-  if (is_load_profiling_) {
-    // register Framework to profiling
-    int result = Msprof::Engine::Init(GE_PROFILING_MODULE, &engine_);
-    if (result != 0) {
-      GELOGE(FAILED, "Register profiling engine failed.");
-      return FAILED;
+  if (is_execute_profiling_) {
+    if (prof_cb_.msprofCtrlCallback == nullptr) {
+      GELOGE(ge::PARAM_INVALID, "MsprofCtrlCallback callback is nullptr.");
+      return ge::PARAM_INVALID;
     }
-    // profiling startup first time
-    GELOGI("Begin to init profiling, device num %zu", device_id_.size());
-    for (size_t i = 0; i < device_id_.size(); ++i) {
-      ret = StartProfiling(0, device_id_[i]);
-      if (ret != SUCCESS) {
-        GELOGW("Profiling start failed on device %d.", device_id_[i]);
-        continue;
-      }
-      GELOGI("Profiling init succ on device %d.", device_id_[i]);
+    int32_t cb_ret = prof_cb_.msprofCtrlCallback(
+        static_cast<uint32_t>(MsprofCtrlCallbackType::MSPROF_CTRL_INIT_GE_OPTIONS),
+        static_cast<void *>(&prof_conf), sizeof(MsprofGeOptions));
+    if (cb_ret != 0) {
+      GELOGE(FAILED, "Call msprofCtrlCallback failed, type:%u, return:%d",
+             static_cast<uint32_t>(MsprofCtrlCallbackType::MSPROF_CTRL_INIT_GE_OPTIONS), cb_ret);
+      return FAILED;
     }
+    GELOGI("Profiling init success");
   } else {
     GELOGI("The profiling is off, skip the initialization");
   }
@@ -103,288 +87,116 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ge::Status ProfilingManager::In
   return SUCCESS;
 }
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ge::Status ProfilingManager::InitFromAclCfg(
-    const std::string &config) {
+ge::Status ProfilingManager::InitFromOptions(const Options &options, MsprofGeOptions &prof_conf) {
 #ifdef DAVINCI_SUPPORT_PROFILING
-  try {
-    is_load_profiling_ = false;
-    is_execute_profiling_ = false;
-    profiling_opts_.clear();
-    op_trace_conf_.clear();
-    Json start_prof_conf = Json::parse(config);
-    Json &prof_conf = start_prof_conf[kStartCfg][0];
-    job_id_ = prof_conf[kJobID];
-    auto iter = prof_conf.find(kProfDir);
-    if (iter != prof_conf.end()) {
-      prof_dir_ = prof_conf[kProfDir];
-    }
-    Json &device_id = prof_conf[kDeviceID];
-    if (device_id.size() != 0) {
-      vector<int32_t>().swap(device_id_);
-      bool is_all = false;
-      for (size_t i = 0; i < device_id.size(); i++) {
-        std::string device_id_str = device_id[i].get<std::string>();
-        if (device_id_str == "all") {
-          is_all = true;
-          break;
-        }
-        device_id_.push_back(std::stoi(device_id_str));
-      }
-      if (is_all) {
-        int32_t count = 0;
-        rtError_t rt_err = rtGetDeviceCount(&count);
-        if (rt_err != RT_ERROR_NONE) {
-          GELOGE(FAILED, "Call rtGetDeviceCount to get device failed.");
-        }
-
-        vector<int32_t>().swap(device_id_);
-        for (int32_t i = 0; i < count; ++i) {
-          device_id_.push_back(i);
-        }
-      }
+  // enable profiling by env
+  char env_profiling_mode[MMPA_MAX_PATH] = { 0x00 };
+  is_load_profiling_ = false; // Change in ProfInit
+  is_execute_profiling_ = false;
+
+  if (options.profiling_mode == "1" && !options.profiling_options.empty()) {
+    // enable profiling by ge option
+    if (memcpy_s(prof_conf.options, MSPROF_OPTIONS_DEF_LEN_MAX, options.profiling_options.c_str(),
+                 options.profiling_options.size()) != EOK) {
+      GELOGE(INTERNAL_ERROR, "copy profiling_options failed.");
+      return INTERNAL_ERROR;
     }
-
-    Json &features = prof_conf[kFeatures];
-    if (ParseFeaturesFromAclCfg(features) != SUCCESS) {
-      GELOGE(FAILED, "Parse feature from acl cfg failed.");
-      return FAILED;
+    is_execute_profiling_ = true;
+    GELOGI("The profiling in options is %s, %s. origin option: %s", options.profiling_mode.c_str(),
+          prof_conf.options, options.profiling_options.c_str());
+  } else {
+    (void)mmGetEnv("PROFILING_MODE", env_profiling_mode, MMPA_MAX_PATH);
+    (void)mmGetEnv("PROFILING_OPTIONS", prof_conf.options, MSPROF_OPTIONS_DEF_LEN_MAX);
+    // The env is invalid
+    if ((strcmp("true", env_profiling_mode) != 0) || (strcmp(prof_conf.options, "\0") == 0)) {
+      return SUCCESS;
     }
-    is_load_profiling_ = true;
+    // enable profiling by env
     is_execute_profiling_ = true;
-  } catch (...) {
-    GELOGE(FAILED, "Json conf is not invalid !");
+    GELOGI("The profiling in env is %s, %s", env_profiling_mode, prof_conf.options); 
+  }
+
+  if (!is_execute_profiling_) {
+    return SUCCESS;
+  }
+
+  // Parse json str for bp fp
+  Status ret = ParseOptions(prof_conf.options);
+  if (ret != ge::SUCCESS) {
+    GELOGE(ge::PARAM_INVALID, "Parse training trace param failed.");
     return ge::PARAM_INVALID;
   }
+
+  if (memcpy_s(prof_conf.jobId, sizeof(prof_conf.jobId), options.job_id.c_str(),
+               sizeof(options.job_id.c_str())) != EOK) {
+    GELOGE(INTERNAL_ERROR, "copy job_id failed.");
+    return INTERNAL_ERROR;
+  }
 #endif
   return ge::SUCCESS;
 }
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ge::Status ProfilingManager::ParseFeaturesFromAclCfg(
-    const Json &features) {
-#ifdef DAVINCI_SUPPORT_PROFILING
+ge::Status ProfilingManager::ParseOptions(const std::string &options) {
+  if (options.empty()) {
+    GELOGE(ge::PARAM_INVALID, "Profiling options is empty.");
+    return ge::PARAM_INVALID;
+  }
   try {
-    for (size_t i = 0; i < features.size(); ++i) {
-      const Json &feature = features[i];
-      if ((feature.find(kName) == feature.end()) || feature[kName].is_null()) {
-        continue;
-      }
-      const std::string &name = feature[kName];
-      if (name == "op_trace") {
-        const Json &conf = feature[kConf];
-        const Json &events = conf[0][kEvents];
-        const std::string &ai_core_events = events[0][kAiCoreEvents];
-        GELOGI("Op trace config from acl ai_core_events:%s", ai_core_events.c_str());
-        is_op_trace_ = true;
-        ProfMgrConf prof_mgr_conf;
-        int result = ProfMgrGetConf(ai_core_events, &prof_mgr_conf);
-        if (result != 0) {
-          GELOGE(FAILED, "ProfMgrGetConf failed.");
-          return FAILED;
-        }
-        op_trace_conf_ = prof_mgr_conf.conf;
-        op_trace_iter_num_ = static_cast<int32_t>(op_trace_conf_.size());
-        GELOGI("Op trace profiling iter num %d,", op_trace_iter_num_);
-      } else if (name == "task_trace") {
-        is_op_trace_ = false;
-        if (feature.find(kConf) != feature.end()) {
-          const Json &conf = feature[kConf];
-          std::stringstream task_trace_conf;
-          task_trace_conf << conf;
-          task_trace_conf_ = task_trace_conf.str();
-        }
-        GELOGI("Task trace config from acl");
-      } else if (name == "system_trace") {
-        is_op_trace_ = false;
-        const Json &conf = feature[kConf];
-        std::stringstream system_trace_conf;
-        system_trace_conf << conf;
-        system_trace_conf_ = system_trace_conf.str();
-        GELOGI("System trace config from acl");
-      }
-      profiling_opts_.push_back(name);
+    Json prof_options = Json::parse(options);
+    const std::string training_trace = prof_options[kTrainingTrace];
+    if (training_trace.empty()) {
+      GELOGI("Training trace will not take effect.");
+      return ge::SUCCESS;
+    }
+    GELOGI("GE profiling training trace:%s", training_trace.c_str());
+    if (training_trace != "on") {
+      GELOGE(ge::PARAM_INVALID, "Training trace param:%s is invalid.", training_trace.c_str());
+      return ge::PARAM_INVALID;
+    }
+    fp_point_ = prof_options[kFpPoint];
+    bp_point_ = prof_options[kBpPoint];
+    if (!fp_point_.empty() && !bp_point_.empty()) {
+      GELOGI("Training trace bp fp is set, bp_point:%s, fp_point:%s.", bp_point_.c_str(), fp_point_.c_str());
     }
   } catch (...) {
-    GELOGE(ge::PARAM_INVALID, "Json conf feature is not invalid !");
+    GELOGE(FAILED, "Json prof_conf options is invalid.");
     return ge::PARAM_INVALID;
   }
-#endif
   return ge::SUCCESS;
 }
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ge::Status ProfilingManager::InitFromOptions(const Options &options) {
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::StopProfiling() {
 #ifdef DAVINCI_SUPPORT_PROFILING
-  // enable profiling support two ways: env and front end
-  char profiling_mode_temp[MMPA_MAX_PATH] = { 0x00 };
-  char prof_options_temp[MMPA_MAX_PATH] = { 0x00 };
-  (void)mmGetEnv("PROFILING_MODE", profiling_mode_temp, MMPA_MAX_PATH);
-  (void)mmGetEnv("PROFILING_OPTIONS", prof_options_temp, MMPA_MAX_PATH );
-  const char *profiling_mode = profiling_mode_temp;
-  const char *prof_options = prof_options_temp;
-  if ((profiling_mode == nullptr) || (strcmp("true", profiling_mode) != 0) || (prof_options == nullptr)) {
-    is_load_profiling_ = false;
-    is_execute_profiling_ = false;
-  } else {
-    std::string prof_options_str = std::string(prof_options);
-    profiling_opts_ = StringUtils::Split(prof_options_str, ':');
-    is_load_profiling_ = true;
-    is_execute_profiling_ = true;
-    GELOGI("The profiling in env is %s, %s", profiling_mode, prof_options);
-  }
-  if (!is_load_profiling_) {
-    const std::string enable_profiling = "1";
-    if (options.profiling_mode != enable_profiling || options.profiling_options.empty()) {
-      is_load_profiling_ = false;
-      is_execute_profiling_ = false;
-      return SUCCESS;
-    } else {
-      profiling_opts_ = StringUtils::Split(options.profiling_options, ':');
-      is_load_profiling_ = true;
-      is_execute_profiling_ = true;
-      GELOGI("The profiling in options is %s, %s", options.profiling_mode.c_str(), options.profiling_options.c_str());
-    }
-  }
-  // features:'training_trace', 'task_trace' or 'op_trace'  etc
-  if (!profiling_opts_.empty()) {
-    if (profiling_opts_[0] == "op_trace") {
-      is_op_trace_ = true;
-      // op trace get conf
-      ProfMgrConf prof_mgr_conf;
-      int result = ProfMgrGetConf("", &prof_mgr_conf);
-      if (result != 0) {
-        GELOGE(FAILED, "ProfMgrGetConf failed.");
-        return FAILED;
-      }
-      op_trace_conf_ = prof_mgr_conf.conf;
-      op_trace_iter_num_ = static_cast<int32_t>(op_trace_conf_.size());
-      GELOGI("op trace profiling iter num %d,", op_trace_iter_num_);
-    } else {
-      is_op_trace_ = false;
-      op_trace_iter_num_ = 1;
+  uint64_t module = GetProfilingModule();
+  // The following if case will not be executed in normal case, inc case of ProfStopProfiling is abnormal
+  int32_t device_num = static_cast<int32_t>(device_id_.size());
+  if (device_num != 0) {
+    auto device_id_ptr = std::unique_ptr<uint32_t[]>(new (std::nothrow) uint32_t[device_num]);
+    if (device_id_ptr == nullptr) {
+      GELOGE(FAILED, "Stop profiling: device id ptr is null.");
+      return;
     }
-  }
-#endif
-  return ge::SUCCESS;
-}
-
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ge::Status ProfilingManager::StartProfiling(int32_t iter_num,
-                                                                                             int32_t device_id) {
-#ifdef DAVINCI_SUPPORT_PROFILING
-  if (!profiling_opts_.empty()) {
-    GELOGI("Start profiling index is %d", iter_num);
-    // current one docker only use one device
-    Json p_device;
-
-    try {
-      // profiling need physical_device_id
-      p_device[kDeviceID] = std::to_string(device_id);
-      p_device[kJobID] = job_id_;
-      p_device[kTraceID] = std::to_string(GetContext().TraceId());
-      if (!prof_dir_.empty()) {
-        p_device[kProfDir] = prof_dir_;
-        GELOGI("Prof dir: %s.", prof_dir_.c_str());
-      }
-
-      Json features;
-      if (is_op_trace_) {
-        Json f;
-        f[kName] = "op_trace";
-        Json conf;
-        if (op_trace_conf_.size() <= static_cast<size_t>(iter_num)) {
-          GELOGE(FAILED, "Op trace iter num is invalid!");
-          return FAILED;
-        }
-        Json events;
-        events[0] = nlohmann::json::parse(op_trace_conf_[iter_num]);
-        conf[0][kEvents] = events;
-        f[kConf] = conf;
-        features[0] = f;
-        if (iter_num == 0) {
-          is_load_ = true;
-        }
-      } else {
-        for (std::vector<std::string>::size_type i = 0; i < profiling_opts_.size(); i++) {
-          Json f;
-          if (profiling_opts_[i] == "system_trace") {
-            f[kConf] = nlohmann::json::parse(system_trace_conf_);
-          } else if (profiling_opts_[i] == "task_trace") {
-            if (!task_trace_conf_.empty()) {
-              f[kConf] = nlohmann::json::parse(task_trace_conf_);
-            }
-          }
-          f[kName] = profiling_opts_[i];
-          features[i] = f;
-        }
-        is_load_ = true;
-      }
-      p_device[kFeatures] = features;
-      // only one device, but sProfMgrStartUp API require for device list
-      Json devices;
-      devices[0] = p_device;
-
-      Json start_cfg;
-      start_cfg[kStartCfg] = devices;
-
-      // convert json to string
-      std::stringstream ss;
-      ss << start_cfg;
-      send_profiling_config_ = ss.str();
-      GELOGI("Profiling config %s\n", send_profiling_config_.c_str());
-    } catch (...) {
-      GELOGE(FAILED, "Op trace json conf is not invalid !");
-      return FAILED;
+    for (int32_t i = 0; i < device_num; i++) {
+      device_id_ptr[i] = static_cast<uint32_t>(device_id_[i]);
     }
-
-    // runtime startup for profiling
-    uint64_t module = GetProfilingModule();
-    int32_t device_num = 1;
-    uint32_t device_id_rt = static_cast<uint32_t>(device_id);
-    GE_CHK_RT_RET(rtProfilerStart(module, device_num, &device_id_rt));
-
-    // call profiling startup API
-    ProfMgrCfg prof_cfg = {send_profiling_config_};
-    void *prof_handle = ProfMgrStartUp(&prof_cfg);
-    if (prof_handle == nullptr) {
-      GELOGW("ProfMgrStartUp failed on device %d ", device_id);
-      return FAILED;
+    rtError_t rt_ret = rtProfilerStop(module, device_num, device_id_ptr.get());
+    if (rt_ret != RT_ERROR_NONE) {
+      GELOGW("Call rtProfilerStop failed, ret:%d", rt_ret);
     }
-    GELOGD("StartProfiling, prof_handle: %p", prof_handle);
-    prof_handle_vec_.push_back(prof_handle);
   }
-#endif
-  return SUCCESS;
-}
-
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::StopProfiling() {
-#ifdef DAVINCI_SUPPORT_PROFILING
-  Msprof::Engine::Reporter *reporter = PluginImpl::GetPluginReporter();
-  if (reporter != nullptr) {
-    int ret = reporter->Flush();
-    GELOGI("Report data end, ret is %d", ret);
+ 
+  // stop profiling
+  if (prof_cb_.msprofCtrlCallback == nullptr) {
+      GELOGE(ge::PARAM_INVALID, "MsprofCtrlCallback callback is nullptr.");
+      return;
   }
-  uint64_t module = GetProfilingModule();
-  int32_t device_num = static_cast<int32_t>(device_id_.size());
-  auto device_id_ptr = std::unique_ptr<uint32_t[]>(new (std::nothrow) uint32_t[device_num]);
-  if (device_id_ptr == nullptr) {
-    GELOGE(FAILED, "Stop profiling: device id ptr is null.");
+  int32_t cb_ret = prof_cb_.msprofCtrlCallback(static_cast<uint32_t>(MsprofCtrlCallbackType::MSPROF_CTRL_FINALIZE),
+                                               nullptr, 0);
+  if (cb_ret != 0) {
+    GELOGW("call msprofCtrlCallback failed, type:%u, return:%d",
+           static_cast<uint32_t>(MsprofCtrlCallbackType::MSPROF_CTRL_FINALIZE), cb_ret);
     return;
   }
-  for (int32_t i = 0; i < device_num; i++) {
-    device_id_ptr[i] = static_cast<uint32_t>(device_id_[i]);
-  }
-  rtError_t rt_ret = rtProfilerStop(module, device_num, device_id_ptr.get());
-  if (rt_ret != RT_ERROR_NONE) {
-    GELOGW("Call rtProfilerStop failed, ret:%d", rt_ret);
-  }
-
-  for (size_t i = 0; i < prof_handle_vec_.size(); ++i) {
-    int result = ProfMgrStop(prof_handle_vec_[i]);
-    if (result != 0) {
-      GELOGW("ProfMgr stop return fail:%d, handle:%p", result, prof_handle_vec_[i]);
-    }
-  }
-  vector<void *>().swap(prof_handle_vec_);
-  is_load_ = false;
-  recv_profiling_config_ = "";
   GELOGI("Stop Profiling success.");
 #endif
 }
@@ -392,12 +204,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::StopProf
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ProfilingTaskDescInfo(
     uint32_t model_id, const std::vector<TaskDescInfo> &task_desc_info, const int32_t &device_id) {
 #ifdef DAVINCI_SUPPORT_PROFILING
-  Msprof::Engine::Reporter *reporter = PluginImpl::GetPluginReporter();
-  if (reporter == nullptr) {
-    GELOGI("Profiling report is nullptr!");
-    return;
-  }
-
   std::string data;
   for (const auto &task : task_desc_info) {
     std::string model_name = task.model_name;
@@ -412,7 +218,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::Profilin
                      .append(std::to_string(stream_id)).append(" ")
                      .append(std::to_string(model_id)).append("\n"));
 
-    Msprof::Engine::ReporterData reporter_data{};
+    ReporterData reporter_data{};
     reporter_data.deviceId = device_id;
     reporter_data.data = (unsigned char *)data.c_str();
     reporter_data.dataLen = data.size();
@@ -422,9 +228,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::Profilin
       return;
     }
 
-    ret = reporter->Report(&reporter_data);
-    if (ret != SUCCESS) {
-      GELOGE(ret, "Reporter data of task_desc_info fail!");
+    int32_t cb_ret = CallMsprofReport(reporter_data);
+    if (cb_ret != 0) {
+      GELOGE(cb_ret, "Reporter data of task_desc_info failed, ret:%d", cb_ret);
       return;
     }
   }
@@ -436,9 +242,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::Profilin
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ProfilingGraphDescInfo(
     uint32_t model_id, const std::vector<ComputeGraphDescInfo> &compute_graph_desc_info, const int32_t &device_id) {
 #ifdef DAVINCI_SUPPORT_PROFILING
-  Msprof::Engine::Reporter *reporter = PluginImpl::GetPluginReporter();
-  GE_IF_BOOL_EXEC(reporter == nullptr, GELOGI("Profiling report is nullptr!"); return;);
-
   std::string data;
   for (const auto &graph : compute_graph_desc_info) {
     data.append("model_name:")
@@ -493,64 +296,52 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::Profilin
     }
 
     data.append(" model_id:").append(std::to_string(model_id));
-
     data.append("\n");
 
-    Msprof::Engine::ReporterData reporter_data{};
-    Report(device_id, data, *reporter, reporter_data);
-
+    GraphDescReport(device_id, data);
     data.clear();
   }
 #endif
 }
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::Report(
-    const int32_t &device_id, const string &data, Msprof::Engine::Reporter &reporter,
-    Msprof::Engine::ReporterData &reporter_data) {
+void ProfilingManager::GraphDescReport(const int32_t &device_id, const string &data) {
 #ifdef DAVINCI_SUPPORT_PROFILING
+  ReporterData reporter_data{};
+  int ret = -1;
+  int32_t cb_ret = -1;
   size_t index = data.size() / kReportMaxLen;
   if (index >= 1) {
     reporter_data.deviceId = device_id;
-    int ret = memcpy_s(reporter_data.tag, MSPROF_ENGINE_MAX_TAG_LEN + 1, "graph_desc_info", sizeof("graph_desc_info"));
+    ret = memcpy_s(reporter_data.tag, MSPROF_ENGINE_MAX_TAG_LEN + 1, "graph_desc_info", sizeof("graph_desc_info"));
     GE_IF_BOOL_EXEC(ret != EOK, GELOGE(ret, "Report data tag of graph_desc_info memcpy error!"); return;);
     for (size_t i = 0; i < index; ++i) {
       reporter_data.data = (unsigned char *)data.c_str() + kReportMaxLen * i;
       reporter_data.dataLen = kReportMaxLen;
-      ret = reporter.Report(&reporter_data);
-      GE_IF_BOOL_EXEC(ret != SUCCESS, GELOGE(ret, "Reporter data of graph_desc_info fail!"); return;);
+      cb_ret = CallMsprofReport(reporter_data);
+      GE_IF_BOOL_EXEC(cb_ret != 0, GELOGE(cb_ret, "Reporter data of graph_desc_info failed, ret:%d", cb_ret); return;);
     }
     reporter_data.dataLen = data.size() - kReportMaxLen * index;
     if (reporter_data.dataLen != 0) {
       reporter_data.data = (unsigned char *)data.c_str() + kReportMaxLen * index;
-      ret = reporter.Report(&reporter_data);
-      GE_IF_BOOL_EXEC(ret != SUCCESS, GELOGE(ret, "Reporter data of graph_desc_info fail!"); return;);
+      cb_ret = CallMsprofReport(reporter_data);
+      GE_IF_BOOL_EXEC(cb_ret != 0, GELOGE(cb_ret, "Reporter data of graph_desc_info failed, ret:%d", cb_ret); return;);
     }
   } else {
     reporter_data.deviceId = device_id;
     reporter_data.data = (unsigned char *)data.c_str();
     reporter_data.dataLen = data.size();
-    int ret = memcpy_s(reporter_data.tag, MSPROF_ENGINE_MAX_TAG_LEN + 1, "graph_desc_info", sizeof("graph_desc_info"));
+    ret = memcpy_s(reporter_data.tag, MSPROF_ENGINE_MAX_TAG_LEN + 1, "graph_desc_info", sizeof("graph_desc_info"));
     GE_IF_BOOL_EXEC(ret != EOK, GELOGE(ret, "Report data tag of graph_desc_info memcpy error!"); return;);
 
-    ret = reporter.Report(&reporter_data);
-    GE_IF_BOOL_EXEC(ret != SUCCESS, GELOGE(ret, "Reporter data of graph_desc_info fail!"); return;);
-  }
-#endif
-}
-
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::PluginUnInit(const std::string &module) const {
-#ifdef DAVINCI_SUPPORT_PROFILING
-  int ret = Msprof::Engine::UnInit(module);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "profiling plugin uninit failed, ret:%d", ret);
+    cb_ret = CallMsprofReport(reporter_data);
+    GE_IF_BOOL_EXEC(cb_ret != 0, GELOGE(cb_ret, "Reporter data of graph_desc_info failed, ret:%d", cb_ret); return;);
   }
 #endif
 }
 
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ReportProfilingData(
     uint32_t model_id, const std::vector<TaskDescInfo> &task_desc_info,
-    const std::vector<ComputeGraphDescInfo> &compute_graph_desc_info,
-    bool check_device) {
+    const std::vector<ComputeGraphDescInfo> &compute_graph_desc_info) {
 #ifdef DAVINCI_SUPPORT_PROFILING
   int32_t logic_device_id = 0;
   rtError_t rt_ret = rtGetDevice(&logic_device_id);
@@ -559,13 +350,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ReportPr
     return;
   }
   GELOGD("current logic_device_id:%d", logic_device_id);
-  if (check_device) {
-    auto ret = std::find(device_id_.begin(), device_id_.end(), logic_device_id);
-    if (ret == device_id_.end()) {
-      GELOGE(FAILED, "get valid phy_device_id failed, profiling report failed.");
-      return;
-    }
-  }
   GELOGD("start ProfilingTaskDescInfo.");
   ProfilingTaskDescInfo(model_id, task_desc_info, logic_device_id);
   GELOGD("start ProfilingGraphDescInfo.");
@@ -574,11 +358,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::ReportPr
 #endif
 }
 
-FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::SetProfilingConfig(
-    const std::string &profiling_cfg) {
-  recv_profiling_config_ = profiling_cfg;
-}
-
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint64_t ProfilingManager::GetProfilingModule() {
   uint64_t module = PROF_MODEL_EXECUTE_MASK |
                     PROF_RUNTIME_API_MASK |
@@ -594,9 +373,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint64_t ProfilingManager::GetP
   return module;
 }
 
-void ProfilingManager::UpdateSubscribeDeviceModuleMap(std::string prof_type,
-                                                      uint32_t device_id,
-                                                      uint64_t module) {
+void ProfilingManager::UpdateSubscribeDeviceModuleMap(std::string prof_type, uint32_t device_id, uint64_t module) {
 #ifdef DAVINCI_SUPPORT_PROFILING
   if (prof_type == kProfModelSubscribe) {
     if (subs_dev_module_.find(device_id) != subs_dev_module_.end()) {
@@ -608,9 +385,13 @@ void ProfilingManager::UpdateSubscribeDeviceModuleMap(std::string prof_type,
       subs_dev_module_[device_id] = dev_info;
     }
   } else if (prof_type == kProfModelUnsubscribe) {
-    if (subs_dev_module_.find(device_id) != subs_dev_module_.end()) {
-      if (subs_dev_module_[device_id].subscribe_count > 0) {
-        subs_dev_module_[device_id].subscribe_count--;
+    auto iter = subs_dev_module_.find(device_id);
+    if (iter != subs_dev_module_.end()) {
+      if (iter->second.subscribe_count > 0) {
+        iter->second.subscribe_count--;
+      }
+      if (iter->second.subscribe_count == 0) {
+        subs_dev_module_.erase(iter);
       }
     }
   } else {
@@ -626,10 +407,11 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfMo
   uint64_t model_load_mask = module & PROF_MODEL_LOAD_MASK;
   if ((subscribe_count_ == 0) && (model_load_mask == PROF_MODEL_LOAD_MASK)) {
     // register framework to profiling
-    int32_t result = Msprof::Engine::Init(GE_PROFILING_MODULE, &engine_);
-    if (result != SUCCESS) {
-      GELOGE(FAILED, "Register profiling engine failed.");
-      return FAILED;
+    // register Framework to profiling
+    int32_t cb_ret = PluginInit();
+    if (cb_ret != 0) {
+      GELOGE(cb_ret, "profiling plugin init failed, ret:%d", cb_ret);
+      return cb_ret;
     }
     GELOGI("Prof subscribe: model load profiling on.");
   }
@@ -647,7 +429,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfMo
   UpdateSubscribeDeviceModuleMap(kProfModelSubscribe, device[0], module);
 
   // Report profiling data
-  Status p_ret = davinci_model->ReportProfilingData(false);
+  Status p_ret = davinci_model->ReportProfilingData();
   if (p_ret != SUCCESS) {
     GELOGE(p_ret, "Report profiling data failed.");
     return p_ret;
@@ -672,6 +454,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfMo
   auto iter = subs_dev_module_.find(device[0]);
   if (iter != subs_dev_module_.end()) {
     if (subs_dev_module_[device[0]].subscribe_count == 1) {
+      // The same device_id, only stop at last time
       rtError_t rt_ret = rtProfilerStop(subs_dev_module_[device[0]].module, dev_num, device);
       if (rt_ret != RT_ERROR_NONE) {
         GELOGE(FAILED, "Runtime profiler stop failed.");
@@ -679,15 +462,15 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfMo
       }
     }
     UpdateSubscribeDeviceModuleMap(kProfModelUnsubscribe, device[0], subs_dev_module_[device[0]].module);
+  } else {
+    GELOGE(FAILED, "The device_id:%u has not been subscribed, do not need to cancel.", device[0]);
+    return FAILED;
   }
 
   subscribe_count_--;
   if (subscribe_count_ == 0) {
-    int32_t ret = Msprof::Engine::UnInit(GE_PROFILING_MODULE);
-    if (ret != SUCCESS) {
-      GELOGE(ret, "Profiling plugin uninit failed, ret:%d", ret);
-      return ret;
-    }
+    // profiling plugin uninit at last subscription
+    PluginUnInit();
   }
 #endif
   return SUCCESS;
@@ -700,11 +483,12 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfIn
 
   if (model_load_mask == PROF_MODEL_LOAD_MASK) {
     // register Framework to profiling
-    int32_t result = Msprof::Engine::Init(GE_PROFILING_MODULE, &engine_);
-    if (result != SUCCESS) {
-      GELOGE(FAILED, "Register profiling engine failed.");
-      return FAILED;
+    int32_t cb_ret = PluginInit();
+    if (cb_ret != 0) {
+      GELOGE(cb_ret, "profiling plugin init failed, ret:%d", cb_ret);
+      return cb_ret;
     }
+
     int32_t device_num = -1;
     rtError_t rt_ret = rtProfilerStart(model_load_mask, device_num, nullptr);
     if (rt_ret != RT_ERROR_NONE) {
@@ -719,7 +503,6 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfIn
   if (training_trace_mask == PROF_TRAINING_TRACE_MASK) {
     is_training_trace_ = true;
   }
-  is_acl_api_mode_ = true;
   GELOGI("Prof init success.");
 #endif
   return SUCCESS;
@@ -730,19 +513,17 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfFi
   std::lock_guard<std::mutex> lock(mutex_);
   is_load_profiling_ = false;
   is_training_trace_ = false;
-  is_acl_api_mode_ = false;
+  is_execute_profiling_ = false;
+
+  // profiling plugin uninit
+  PluginUnInit();
 
-  int32_t ret = Msprof::Engine::UnInit(GE_PROFILING_MODULE);
-  if (ret != SUCCESS) {
-    GELOGE(ret, "Profiling plugin uninit failed, ret:%d", ret);
-  }
   int32_t dev_num = -1;
   rtError_t rt_ret = rtProfilerStop(PROF_MODEL_LOAD_MASK, dev_num, nullptr);
   if (rt_ret != RT_ERROR_NONE) {
     GELOGE(FAILED, "Runtime profiler stop failed.");
     return FAILED;
   }
-
   for (auto device_id_module : device_id_module_map_) {
     if (device_id_module.second != 0) {
       uint32_t device_id = static_cast<uint32_t>(device_id_module.first);
@@ -792,6 +573,7 @@ Status ProfilingManager::ProfParseDeviceId(const std::map<std::string, std::stri
         return FAILED;
       } catch (std::out_of_range &) {
         GELOGE(FAILED, "Device id: %s is  out of range.", decvice_id[i].c_str());
+        return FAILED;
       } catch (...) {
         GELOGE(FAILED, "Device id: %s cannot change to int.", decvice_id[i].c_str());
         return FAILED;
@@ -818,6 +600,7 @@ Status ProfilingManager::ProfParseParam(const std::map<std::string, std::string>
       return FAILED;
     } catch (std::out_of_range &) {
       GELOGE(FAILED, "Device num: %s is  out of range.", iter->second.c_str());
+      return FAILED;
     } catch (...) {
       GELOGE(FAILED, "Device num: %s cannot change to int.", iter->second.c_str());
       return FAILED;
@@ -859,7 +642,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
   for (int32_t i = 0; i < device_num; i++) {
     device_id_ptr[i] = static_cast<uint32_t>(device_list[i]);
   }
-  GELOGD("Runtime config param: 0x%llx, device num: %d.", module, device_num);
+  GELOGI("Runtime config param: 0x%llx, device num: %d.", module, device_num);
 
   rtError_t rt_ret = rtProfilerStart(module, device_num, device_id_ptr.get());
   if (rt_ret != RT_ERROR_NONE) {
@@ -878,7 +661,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
     GELOGW("Prof start: load model module is invalid.");
   }
   UpdateDeviceIdModuleMap(kProfStart, module, device_list);
-  GELOGD("Prof start profiling success.");
+  GELOGI("Prof start profiling success.");
 #endif
   return SUCCESS;
 }
@@ -901,7 +684,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
   for (int32_t i = 0; i < device_num; i++) {
     device_id_ptr[i] = static_cast<uint32_t>(device_list[i]);
   }
-  GELOGD("Prof stop: runtime config param: 0x%llx, device num: %d", module, device_num);
+  GELOGI("Prof stop: runtime config param: 0x%llx, device num: %d", module, device_num);
   rtError_t rt_ret = rtProfilerStop(module, device_num, device_id_ptr.get());
   if (rt_ret != RT_ERROR_NONE) {
     GELOGE(FAILED, "Prof stop: runtime profiler config proc failed.");
@@ -921,7 +704,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::ProfSt
     GELOGW("Prof stop: load model module is invalid.");
   }
   UpdateDeviceIdModuleMap(kProfStop, module, device_list);
-  GELOGD("Prof stop profiling success.");
+  GELOGI("Prof stop profiling success.");
 #endif
   return SUCCESS;
 }
@@ -963,47 +746,90 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ProfilingManager::Profilin
   if (rt_ret != RT_ERROR_NONE) {
     GELOGE(rt_ret, "Runtime get logic_device_id failed, current logic_device_id:%d", logic_device_id);
   }
-  GELOGD("Current logic_device_id:%d", logic_device_id);
+  GELOGI("Current logic_device_id:%d", logic_device_id);
 
   bool execute_model_prof_on = false;
   auto iter = std::find(device_id_.begin(), device_id_.end(), logic_device_id);
   if (iter != device_id_.end()) {
     execute_model_prof_on = true;
   }
-  GELOGD("Flag is_execute_profiling: %d, execute_model_prof_on: %d", is_execute_profiling_, execute_model_prof_on);
-  return is_execute_profiling_ || execute_model_prof_on;
+  GELOGI("Flag is_execute_profiling: %d, execute_model_prof_on: %d", is_execute_profiling_, execute_model_prof_on);
+  return  execute_model_prof_on;
 }
 
-/**
- * @brief Profiling PluginImpl
- */
-// PluginImpl static variable init
-Msprof::Engine::Reporter *PluginImpl::reporter_ = nullptr;
-
-PluginImpl::PluginImpl(const std::string &module) : module_(module) { GELOGI("Create PluginImpl\n"); }
-
-int PluginImpl::Init(const Msprof::Engine::Reporter *reporter) {
-  GELOGI("PluginImpl init");
-  reporter_ = const_cast<Msprof::Engine::Reporter *>(reporter);
-  return 0;
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::PluginInit() const {
+  if (prof_cb_.msprofReporterCallback == nullptr) {
+    GELOGE(ge::PARAM_INVALID, "MsprofReporterCallback callback is nullptr.");
+    return ge::PARAM_INVALID;
+  }
+  return prof_cb_.msprofReporterCallback(
+      static_cast<uint32_t>(MsprofReporterModuleId::MSPROF_MODULE_FRAMEWORK),
+      static_cast<uint32_t>(MsprofReporterCallbackType::MSPROF_REPORTER_INIT),
+      nullptr, 0);
 }
 
-int PluginImpl::UnInit() {
-  GELOGI("PluginImpl Uninit");
-  reporter_ = nullptr;
-  return 0;
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::PluginUnInit() const {
+#ifdef DAVINCI_SUPPORT_PROFILING
+  if (prof_cb_.msprofReporterCallback == nullptr) {
+    GELOGE(ge::PARAM_INVALID, "MsprofReporterCallback callback is nullptr.");
+    return;
+  }
+  int32_t cb_ret = prof_cb_.msprofReporterCallback(
+      static_cast<uint32_t>(MsprofReporterModuleId::MSPROF_MODULE_FRAMEWORK),
+      static_cast<uint32_t>(MsprofReporterCallbackType::MSPROF_REPORTER_UNINIT),
+      nullptr, 0);
+  if (cb_ret != 0) {
+    GELOGW("profiling plugin uninit failed, ret:%d", cb_ret);
+  }
+#endif
 }
 
-Msprof::Engine::PluginIntf *ProfilingEngineImpl::CreatePlugin() {
-  GELOGI(" Create Plugin");
-  return new (std::nothrow) PluginImpl(GE_PROFILING_MODULE);
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ProfilingManager::CallMsprofReport(
+    ReporterData &reporter_data) const {
+  if (prof_cb_.msprofReporterCallback == nullptr) {
+    GELOGE(ge::PARAM_INVALID, "MsprofReporterCallback callback is nullptr.");
+    return ge::PARAM_INVALID;
+  }    
+  return prof_cb_.msprofReporterCallback(
+      static_cast<uint32_t>(MsprofReporterModuleId::MSPROF_MODULE_FRAMEWORK),
+      static_cast<uint32_t>(MsprofReporterCallbackType::MSPROF_REPORTER_REPORT),
+      static_cast<void *>(&reporter_data), sizeof(ReporterData));
 }
 
-int ProfilingEngineImpl::ReleasePlugin(Msprof::Engine::PluginIntf *plugin) {
-  if (plugin != nullptr) {
-    delete plugin;
-    plugin = nullptr;
+FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY void ProfilingManager::GetFpBpPoint(
+    std::string &fp_point, std::string &bp_point) {
+  // Env or options mode, fp_point_/bp_point_ have initiliazed on profiling init
+  if (!fp_point_.empty() && !bp_point_.empty()) {
+    fp_point = fp_point_;
+    bp_point = bp_point_;
+    GELOGI("Bp Fp have been initialized in env or options. bp_point: %s, fp_point: %s", bp_point.c_str(), fp_point.c_str());
+    return;
+  }
+  // ProfApi mode and training trace is set
+  try {
+    char env_profiling_options[MSPROF_OPTIONS_DEF_LEN_MAX] = { 0x00 };
+    INT32 ret = mmGetEnv("PROFILING_OPTIONS", env_profiling_options, MSPROF_OPTIONS_DEF_LEN_MAX);
+    if (ret != EN_OK) {
+      GELOGI("PROFILING_OPTIONS env is not exist.");
+      return;
+    }
+    GELOGI("Parse env PROFILING_OPTIONS:%s.", env_profiling_options);
+    Json prof_options = Json::parse(env_profiling_options);
+
+    fp_point_ = prof_options[kFpPoint];
+    bp_point_ = prof_options[kBpPoint];
+
+    fp_point = fp_point_;
+    bp_point = bp_point_;
+    if (!fp_point_.empty() && !bp_point_.empty()) {
+      GELOGI("Training trace bp fp is set, bp_point:%s, fp_point:%s.", bp_point_.c_str(), fp_point_.c_str());
+    }
+  } catch (...) {
+    GELOGE(FAILED, "Json prof options is invalid.");
+    return;
   }
-  return 0;
+  return;
 }
+
+
 }  // namespace ge

ge/common/profiling/profiling_manager.h

@@ -26,9 +26,7 @@
 #include "framework/common/ge_inner_error_codes.h"
 #include "framework/common/ge_types.h"
 #include "external/register/register_types.h"
-#include "toolchain/prof_engine.h"
-#include "toolchain/prof_mgr_core.h"
-#include "toolchain/prof_acl_api.h"
+#include "toolchain/prof_callback.h"
 
 using std::map;
 using std::string;
@@ -37,35 +35,33 @@ using Json = nlohmann::json;
 
 namespace {
   const std::string GE_PROFILING_MODULE = "Framework";
+  // DataTypeConfig MASK
+  #define PROF_ACL_API_MASK                0x0001
+  #define PROF_TASK_TIME_MASK              0x0002
+  #define PROF_AICORE_METRICS_MASK         0x0004
+  #define PROF_AICPU_TRACE_MASK            0x0008
+  #define PROF_MODEL_EXECUTE_MASK          0x0010
+  #define PROF_RUNTIME_API_MASK            0x0020
+  #define PROF_RUNTIME_TRACE_MASK          0x0040
+  #define PROF_SCHEDULE_TIMELINE_MASK      0x0080
+  #define PROF_SCHEDULE_TRACE_MASK         0x0100
+  #define PROF_AIVECTORCORE_METRICS_MASK   0x0200
+  #define PROF_SUBTASK_TIME_MASK           0x0400
+  #define PROF_TRAINING_TRACE_MASK         0x0800
+  #define PROF_HCCL_TRACE_MASK             0x1000
+  #define PROF_DATA_PROCESS_MASK           0x2000
+  #define PROF_MODEL_LOAD_MASK             0x8000000000000000
+
 }  // namespace
 namespace ge {
 struct DeviceSubsInfo {
   uint64_t module;
   uint32_t subscribe_count;
 };
-// register Plugin
-class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY PluginImpl : public Msprof::Engine::PluginIntf {
- public:
-  explicit PluginImpl(const std::string &module);
-  ~PluginImpl() {}
-
-  int Init(const Msprof::Engine::Reporter *reporter);
-  int UnInit();
-  static Msprof::Engine::Reporter *GetPluginReporter() { return reporter_; }
 
- private:
-  static Msprof::Engine::Reporter *reporter_;
-  std::string module_;
-};
-
-// register Engine
-class ProfilingEngineImpl : public Msprof::Engine::EngineIntf {
- public:
-  ProfilingEngineImpl() {}
-  ~ProfilingEngineImpl() {}
-
-  Msprof::Engine::PluginIntf *CreatePlugin();
-  int ReleasePlugin(Msprof::Engine::PluginIntf *plugin);
+struct MsprofCallback {
+  MsprofCtrlCallback msprofCtrlCallback;
+  MsprofReporterCallback msprofReporterCallback;
 };
 
 class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager {
@@ -73,68 +69,54 @@ class FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY ProfilingManager {
   ProfilingManager();
   virtual ~ProfilingManager();
   static ProfilingManager &Instance();
-  ge::Status Init(const Options &options);
-  ge::Status InitFromOptions(const Options &options);
-  ge::Status InitFromAclCfg(const std::string &config);
-  ge::Status StartProfiling(int32_t iter, int32_t device_id);
-  void UpdateSubscribeDeviceModuleMap(std::string prof_type, uint32_t device_id, uint64_t module);
-  ge::Status ProfModelSubscribe(uint64_t module, void *model);
-  ge::Status ProfModelUnsubscribe(void *model);
-  ge::Status ProfInit(uint64_t module);
-  ge::Status ProfFinalize();
-  ge::Status ProfStartProfiling(uint64_t module, const std::map<std::string, std::string> &config_para);
-  ge::Status ProfStopProfiling(uint64_t module, const std::map<std::string, std::string> &config_para);
+  Status Init(const Options &options);
+  Status ProfInit(uint64_t module);
+  Status ProfFinalize();
+  Status ProfStartProfiling(uint64_t module, const std::map<std::string, std::string> &config_para);
+  Status ProfStopProfiling(uint64_t module, const std::map<std::string, std::string> &config_para);
+  Status ProfModelSubscribe(uint64_t module, void *model);
+  Status ProfModelUnsubscribe(void *model);
   void StopProfiling();
-  bool ProfilingOpTraceOn() const { return is_op_trace_; }
-  bool ProfilingLoadFlag() const { return is_load_; }
   bool ProfilingTrainingTraceOn() const { return is_training_trace_; }
   bool ProfilingModelLoadOn() const { return is_load_profiling_; }
   bool ProfilingModelExecuteOn() const;
-  bool ProfilingOn() const { return is_load_profiling_ && is_execute_profiling_; } // only used  by command pattern
-  bool IsAclApiMode() const { return is_acl_api_mode_; }
-  int32_t GetOpTraceIterNum() const { return op_trace_iter_num_; }
+  bool ProfilingOn() const { return is_load_profiling_ && is_execute_profiling_; } // is_execute_profiling_ only used by ge option and env
   void ReportProfilingData(uint32_t model_id, const std::vector<TaskDescInfo> &task_desc_info,
-                           const std::vector<ComputeGraphDescInfo> &compute_graph_desc_info,
-                           bool check_device);
-  void Report(const int32_t &device_id, const string &data, Msprof::Engine::Reporter &reporter,
-              Msprof::Engine::ReporterData &reporter_data);
+                           const std::vector<ComputeGraphDescInfo> &compute_graph_desc_info);
   void ProfilingTaskDescInfo(uint32_t model_id, const std::vector<TaskDescInfo> &task_desc_info,
                              const int32_t &device_id);
   void ProfilingGraphDescInfo(uint32_t model_id, const std::vector<ComputeGraphDescInfo> &compute_graph_desc_info,
                               const int32_t &device_id);
-  void SetProfilingConfig(const string &profiling_cfg);
-  vector<int32_t> GetProfilingDeviceId() const { return  device_id_; }
-  void PluginUnInit(const std::string &module) const;
+  Status PluginInit() const;
+  void PluginUnInit() const;
+  Status CallMsprofReport(ReporterData &reporter_data) const;
+  struct MsprofCallback &GetMsprofCallback() { return prof_cb_; }
+  void SetMsprofCtrlCallback(MsprofCtrlCallback func) { prof_cb_.msprofCtrlCallback = func; }
+  void SetMsprofReporterCallback(MsprofReporterCallback func) { prof_cb_.msprofReporterCallback = func; }
+  void GetFpBpPoint(std::string &fp_point, std::string &bp_point);
  private:
-  ge::Status ParseFeaturesFromAclCfg(const Json &feature);
-  ge::Status ProfParseParam(const std::map<std::string, std::string> &config_para, int32_t &device_num,
-                            vector<int32_t> &device_list);
-  ge::Status ProfParseDeviceId(const std::map<std::string, std::string> &config_para,
+  Status InitFromOptions(const Options &options, MsprofGeOptions &prof_conf);
+  Status ParseOptions(const std::string &options);
+  Status ProfParseParam(const std::map<std::string, std::string> &config_para, int32_t &device_num,
+                        vector<int32_t> &device_list);
+  Status ProfParseDeviceId(const std::map<std::string, std::string> &config_para,
                                vector<int32_t> &device_list);
   uint64_t GetProfilingModule();
+  void GraphDescReport(const int32_t &device_id, const string &data);
   void UpdateDeviceIdModuleMap(string prof_type, uint64_t module, const vector<int32_t> &device_list);
-  bool is_load_profiling_ = false;
-  bool is_execute_profiling_ = false;
-  bool is_op_trace_ = false;
-  bool is_load_ = false;
-  bool is_training_trace_ = false;
-  bool is_acl_api_mode_ = false;
-  int32_t op_trace_iter_num_ = 0;
-  string job_id_;
-  string prof_dir_;
+  void UpdateSubscribeDeviceModuleMap(std::string prof_type, uint32_t device_id, uint64_t module);
+
+  bool is_load_profiling_;
+  bool is_execute_profiling_;
+  bool is_training_trace_;
   vector<int32_t> device_id_;
-  vector<string> op_trace_conf_;
-  vector<string> profiling_opts_;
-  vector<void *> prof_handle_vec_;
-  string recv_profiling_config_;
-  string send_profiling_config_;
-  string system_trace_conf_;
-  string task_trace_conf_;
-  const ProfilingEngineImpl engine_;
   map<int32_t, uint64_t> device_id_module_map_; // key: device_id, value: profiling on module
   map<uint32_t, DeviceSubsInfo> subs_dev_module_; // key: device_id, value: profiling on module
   uint32_t subscribe_count_;
   std::mutex mutex_;
+  MsprofCallback prof_cb_;
+  std::string fp_point_;
+  std::string bp_point_;
 };
 }  // namespace ge
 #endif  // GE_COMMON_PROFILING_PROFILING_MANAGER_H_

ge/common/types.cc

@@ -801,7 +801,7 @@ const uint32_t XRGB_CHN_NUM = 4;
 ///
 const bool DEFAULT_GLOBAL_POOLING = false;
 
-const uint32_t MODEL_VERSION = 0x10000000; ///< Model version 1.0///
+const uint32_t MODEL_VERSION = 0x20000000; ///< Model version 2.0///
 
 // Eltwise's input size
 const int ELTWISE_MIN_INPUT_SIZE = 2;

ge/common/util.cc

@@ -51,14 +51,15 @@ namespace {
  * If such an exception is encountered during operation,
  * the proto file can be divided into several small files or the limit value can be increased.
  */
-const int kProtoReadBytesLimit = INT_MAX;     // Max size of 2 GB minus 1 byte.
-const int kWarningThreshold = 536870912 * 2;  // 536870912 represent 512M
+const int kFileSizeOutLimitedOrOpenFailed = -1;
+const int kProtoReadBytesLimit = INT_MAX;  // Max size of 2 GB minus 1 byte.
+const int kWarningThreshold = 1073741824;  // 536870912 * 2 536870912 represent 512M
 
 /// The maximum length of the file.
-const uint32_t kMaxFileSizeLimit = UINT32_MAX; // 4G for now
+const uint32_t kMaxFileSizeLimit = UINT32_MAX;  // 4G for now
 const int kMaxBuffSize = 256;
 const char *const kPathValidReason = "The path can only contain 'a-z' 'A-Z' '0-9' '-' '.' '_' and chinese character";
-constexpr uint32_t kMaxConfigFileByte = 10 * 1024 * 1024;
+constexpr uint32_t kMaxConfigFileByte = 10485760;  // 10 * 1024 * 1024
 }  // namespace
 
 namespace ge {
@@ -76,7 +77,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromBinaryFile(co
   std::string real_path = RealPath(file);
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return false, "pb file path '%s' not valid", file);
 
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "file size not valid.");
+  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == kFileSizeOutLimitedOrOpenFailed, return false,
+                                 "file size not valid.");
 
   std::ifstream fs(real_path, std::ifstream::in | std::ifstream::binary);
   if (!fs.is_open()) {
@@ -118,20 +120,20 @@ long GetFileLength(const std::string &input_file) {
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), return -1, "input_file path '%s' not valid", input_file.c_str());
   unsigned long long file_length = 0;
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
-      mmGetFileSize(input_file.c_str(), &file_length) != EN_OK,
-      ErrorManager::GetInstance().ATCReportErrMessage("E19001", {"file", "errmsg"}, {input_file, strerror(errno)});
-      return -1, "Open file[%s] failed. %s", input_file.c_str(), strerror(errno));
+    mmGetFileSize(input_file.c_str(), &file_length) != EN_OK,
+    ErrorManager::GetInstance().ATCReportErrMessage("E19001", {"file", "errmsg"}, {input_file, strerror(errno)});
+    return kFileSizeOutLimitedOrOpenFailed, "Open file[%s] failed. %s", input_file.c_str(), strerror(errno));
 
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((file_length == 0),
                                  ErrorManager::GetInstance().ATCReportErrMessage("E19015", {"filepath"}, {input_file});
                                  return -1, "File[%s] size is 0, not valid.", input_file.c_str());
 
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(file_length > kMaxFileSizeLimit,
-                                 ErrorManager::GetInstance().ATCReportErrMessage(
-                                     "E19016", {"filepath", "filesize", "maxlen"},
-                                     {input_file, std::to_string(file_length), std::to_string(kMaxFileSizeLimit)});
-                                 return -1, "File[%s] size %lld is out of limit: %d.", input_file.c_str(), file_length,
-                                        kMaxFileSizeLimit);
+  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
+    file_length > kMaxFileSizeLimit, ErrorManager::GetInstance().ATCReportErrMessage(
+                                       "E19016", {"filepath", "filesize", "maxlen"},
+                                       {input_file, std::to_string(file_length), std::to_string(kMaxFileSizeLimit)});
+    return kFileSizeOutLimitedOrOpenFailed, "File[%s] size %lld is out of limit: %d.", input_file.c_str(), file_length,
+           kMaxFileSizeLimit);
   return static_cast<long>(file_length);
 }
 
@@ -187,7 +189,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadBytesFromBinaryFile(co
   std::streamsize size = file.tellg();
 
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG((size <= 0), file.close(); return false, "file length <= 0, not valid.");
-  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(size > static_cast<int64_t >(kMaxFileSizeLimit), file.close();
+  GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(size > static_cast<int64_t>(kMaxFileSizeLimit), file.close();
                                  return false, "file size %ld is out of limit: %d.", size, kMaxFileSizeLimit);
 
   file.seekg(0, std::ios::beg);  // [no need to check value]
@@ -210,8 +212,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY int CreateDirectory(const std::
   GE_CHK_BOOL_EXEC(!directory_path.empty(), return -1, "directory path is empty.");
   auto dir_path_len = directory_path.length();
   if (dir_path_len >= MMPA_MAX_PATH) {
-    ErrorManager::GetInstance().ATCReportErrMessage(
-        "E19002", {"filepath", "size"}, {directory_path, std::to_string(MMPA_MAX_PATH)});
+    ErrorManager::GetInstance().ATCReportErrMessage("E19002", {"filepath", "size"},
+                                                    {directory_path, std::to_string(MMPA_MAX_PATH)});
     GELOGW("Path[%s] len is too long, it must be less than %d", directory_path.c_str(), MMPA_MAX_PATH);
     return -1;
   }
@@ -224,8 +226,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY int CreateDirectory(const std::
         if (ret != 0) {
           if (errno != EEXIST) {
             ErrorManager::GetInstance().ATCReportErrMessage("E19006", {"path"}, {directory_path});
-            GELOGW("Can not create directory %s. Make sure the directory exists and writable.",
-                   directory_path.c_str());
+            GELOGW("Can not create directory %s. Make sure the directory exists and writable.", directory_path.c_str());
             return ret;
           }
         }
@@ -265,7 +266,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromText(const ch
 
   std::string real_path = RealPath(file);
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(real_path.empty(), ErrorManager::GetInstance().ATCReportErrMessage(
-                                                        "E19000", {"path", "errmsg"}, {file, strerror(errno)});
+                                                      "E19000", {"path", "errmsg"}, {file, strerror(errno)});
                                  return false, "Path[%s]'s realpath is empty, errmsg[%s]", file, strerror(errno));
 
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(GetFileLength(real_path) == -1, return false, "file size not valid.");
@@ -301,13 +302,13 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool ReadProtoFromMem(const cha
   google::protobuf::io::IstreamInputStream input(&fs);
   bool ret = google::protobuf::TextFormat::Parse(&input, message);
   GE_IF_BOOL_EXEC(
-      !ret, GELOGE(ret, "Call [google::protobuf::TextFormat::Parse] func ret fail, please check your text file."));
+    !ret, GELOGE(ret, "Call [google::protobuf::TextFormat::Parse] func ret fail, please check your text file."));
 
   return ret;
 }
 
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint64_t GetCurrentTimestamp() {
-  mmTimeval tv {};
+  mmTimeval tv{};
   int ret = mmGetTimeOfDay(&tv, nullptr);
   GE_LOGE_IF(ret != EN_OK, "Func gettimeofday may failed: ret=%d", ret);
   auto total_use_time = tv.tv_usec + tv.tv_sec * 1000000;  // 1000000: seconds to microseconds
@@ -315,7 +316,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint64_t GetCurrentTimestamp()
 }
 
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY uint32_t GetCurrentSecondTimestap() {
-  mmTimeval tv {};
+  mmTimeval tv{};
   int ret = mmGetTimeOfDay(&tv, nullptr);
   GE_LOGE_IF(ret != EN_OK, "Func gettimeofday may failed: ret=%d", ret);
   auto total_use_time = tv.tv_sec;  // seconds
@@ -350,8 +351,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckInt64MulOverflow(int6
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY std::string RealPath(const char *path) {
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(path == nullptr, return "", "path pointer is NULL.");
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(strlen(path) >= MMPA_MAX_PATH,
-      ErrorManager::GetInstance().ATCReportErrMessage("E19002", {"filepath", "size"}, {path, std::to_string(MMPA_MAX_PATH)});
-      return "", "Path[%s] len is too long, it must be less than %d", path, MMPA_MAX_PATH);
+                                 ErrorManager::GetInstance().ATCReportErrMessage("E19002", {"filepath", "size"},
+                                                                                 {path, std::to_string(MMPA_MAX_PATH)});
+                                 return "", "Path[%s] len is too long, it must be less than %d", path, MMPA_MAX_PATH);
 
   // Nullptr is returned when the path does not exist or there is no permission
   // Return absolute path when path is accessible
@@ -385,16 +387,16 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckInputPathValid(const
   // Path section: Support upper and lower case letters, numbers dots(.) chinese and underscores
   // File name section: Support upper and lower case letters, numbers, underscores chinese and dots(.)
 #ifdef __GNUC__
-        std::string mode = "^[\u4e00-\u9fa5A-Za-z0-9./_-]+$";
+  std::string mode = "^[\u4e00-\u9fa5A-Za-z0-9./_-]+$";
 #else
-        std::string mode = "^[a-zA-Z]:([\\\\/][^\\s\\\\/:*?<>\"|][^\\\\/:*?<>\"|]*)*([/\\\\][^\\s\\\\/:*?<>\"|])?$";
+  std::string mode = "^[a-zA-Z]:([\\\\/][^\\s\\\\/:*?<>\"|][^\\\\/:*?<>\"|]*)*([/\\\\][^\\s\\\\/:*?<>\"|])?$";
 #endif
 
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
-      !ValidateStr(real_path, mode),
-      ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
-                                                      {atc_param, real_path, kPathValidReason});
-      return false, "Invalid value for %s[%s], %s.", atc_param.c_str(), real_path.c_str(), kPathValidReason);
+    !ValidateStr(real_path, mode),
+    ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
+                                                    {atc_param, real_path, kPathValidReason});
+    return false, "Invalid value for %s[%s], %s.", atc_param.c_str(), real_path.c_str(), kPathValidReason);
 
   // The absolute path points to a file that is not readable
   if (mmAccess2(real_path.c_str(), M_R_OK) != EN_OK) {
@@ -416,24 +418,25 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY bool CheckOutputPathValid(const
   }
 
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(strlen(file_path.c_str()) >= MMPA_MAX_PATH,
-      ErrorManager::GetInstance().ATCReportErrMessage(
-          "E19002", {"filepath", "size"}, {file_path, std::to_string(MMPA_MAX_PATH)});
-      return "", "Path[%s] len is too long, it must be less than %d", file_path.c_str(), MMPA_MAX_PATH);
+                                 ErrorManager::GetInstance().ATCReportErrMessage(
+                                   "E19002", {"filepath", "size"}, {file_path, std::to_string(MMPA_MAX_PATH)});
+                                 return "", "Path[%s] len is too long, it must be less than %d", file_path.c_str(),
+                                        MMPA_MAX_PATH);
 
   // A regular matching expression to verify the validity of the input file path
   // Path section: Support upper and lower case letters, numbers dots(.) chinese and underscores
   // File name section: Support upper and lower case letters, numbers, underscores chinese and dots(.)
 #ifdef __GNUC__
-     std::string mode = "^[\u4e00-\u9fa5A-Za-z0-9./_-]+$";
+  std::string mode = "^[\u4e00-\u9fa5A-Za-z0-9./_-]+$";
 #else
-     std::string mode = "^[a-zA-Z]:([\\\\/][^\\s\\\\/:*?<>\"|][^\\\\/:*?<>\"|]*)*([/\\\\][^\\s\\\\/:*?<>\"|])?$";
+  std::string mode = "^[a-zA-Z]:([\\\\/][^\\s\\\\/:*?<>\"|][^\\\\/:*?<>\"|]*)*([/\\\\][^\\s\\\\/:*?<>\"|])?$";
 #endif
 
   GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(
-      !ValidateStr(file_path, mode),
-      ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
-                                                      {atc_param, file_path, kPathValidReason});
-      return false, "Invalid value for %s[%s], %s.", atc_param.c_str(), file_path.c_str(), kPathValidReason);
+    !ValidateStr(file_path, mode),
+    ErrorManager::GetInstance().ATCReportErrMessage("E10001", {"parameter", "value", "reason"},
+                                                    {atc_param, file_path, kPathValidReason});
+    return false, "Invalid value for %s[%s], %s.", atc_param.c_str(), file_path.c_str(), kPathValidReason);
 
   std::string real_path = RealPath(file_path.c_str());
   // Can get absolute path (file exists)

ge/executor/CMakeLists.txt

@@ -17,6 +17,7 @@ set(SRC_LIST
     "../common/dump/dump_properties.cc"
     "../common/dump/dump_manager.cc"
     "../common/dump/dump_op.cc"
+    "../common/profiling/ge_profiling.cc"
     "../graph/load/graph_loader.cc"
     "../graph/execute/graph_execute.cc"
     "../omm/csa_interact.cc"
@@ -172,6 +173,7 @@ target_compile_definitions(ge_executor PRIVATE
     google=ascend_private
     $<IF:$<STREQUAL:${TARGET_SYSTEM_NAME},Windows>,OS_TYPE=WIN,OS_TYPE=0>
     $<$<STREQUAL:${TARGET_SYSTEM_NAME},Windows>:SECUREC_USING_STD_SECURE_LIB=0 NOMINMAX>
+    LOG_CPP
 )
 
 target_include_directories(ge_executor PRIVATE
@@ -244,7 +246,6 @@ target_link_libraries(ge_executor_shared PRIVATE
     mmpa
     graph
     register
-    msprof
     error_manager
     ascend_hal_stub
     ascend_protobuf

ge/executor/ge_executor.cc

@@ -283,7 +283,8 @@ Status GeExecutor::Initialize() {
   // Start profiling
   Options profiling_options;
   profiling_options.device_id = 0;
-  profiling_options.job_id = "";
+  // job id need to be set, the value is meaningless;
+  profiling_options.job_id = "1";
   ProfilingManager::Instance().Init(profiling_options);
 
   isInit_ = true;
@@ -303,7 +304,7 @@ Status GeExecutor::Finalize() {
   // Stop profiling
   if (ProfilingManager::Instance().ProfilingOn()) {
     ProfilingManager::Instance().StopProfiling();
-    ProfilingManager::Instance().PluginUnInit(GE_PROFILING_MODULE);
+    ProfilingManager::Instance().PluginUnInit();
   }
 
   GELOGI("Uninit GeExecutor over.");
@@ -638,7 +639,8 @@ Status GeExecutor::UnloadModel(uint32_t model_id) {
     return ACL_ERROR_GE_INTERNAL_ERROR;
   }
 
-  std::shared_ptr<hybrid::HybridDavinciModel> hybrid_davinci_model = ModelManager::GetInstance()->GetHybridModel(model_id);
+  std::shared_ptr<hybrid::HybridDavinciModel> hybrid_davinci_model =
+      ModelManager::GetInstance()->GetHybridModel(model_id);
   if (hybrid_davinci_model != nullptr) {
     uint64_t session_id = hybrid_davinci_model->GetSessionId();
     VarManagerPool::Instance().RemoveVarManager(session_id);

ge/executor/module.mk

@@ -8,6 +8,7 @@ local_ge_executor_src_files :=  \
     ../common/dump/dump_op.cc \
     ../common/ge/plugin_manager.cc \
     ../common/ge/op_tiling_manager.cc \
+    ../common/profiling/ge_profiling.cc \
     ../graph/load/graph_loader.cc \
     ../graph/execute/graph_execute.cc \
     ../omm/csa_interact.cc \
@@ -177,7 +178,6 @@ local_ge_executor_shared_library :=        \
     libmmpa                                \
     libgraph                               \
     libregister                            \
-    libmsprof                              \
     liberror_manager                       \
 
 local_ge_executor_ldflags := -lrt -ldl     \
@@ -234,7 +234,6 @@ LOCAL_SHARED_LIBRARIES :=                  \
     libmmpa                                \
     libgraph                               \
     libregister                            \
-    libmsprof                              \
     liberror_manager                       \
     stub/libascend_hal                     \
 
@@ -272,7 +271,6 @@ LOCAL_SHARED_LIBRARIES :=                  \
     libruntime                             \
     libslog                                \
     libmmpa                                \
-    libmsprof                              \
 
 LOCAL_LDFLAGS += $(local_ge_executor_ldflags)
 
@@ -304,7 +302,6 @@ LOCAL_SHARED_LIBRARIES :=                  \
     libruntime                             \
     libslog                                \
     libmmpa                                \
-    libmsprof                              \
 
 ifeq ($(device_os),android)
 LOCAL_LDFLAGS += -ldl

ge/ge_inference.mk

@@ -109,6 +109,7 @@ OMG_HOST_SRC_FILES := \
     graph/passes/atomic_addr_clean_pass.cc \
     graph/passes/mark_same_addr_pass.cc \
     graph/passes/mark_graph_unknown_status_pass.cc \
+    graph/passes/dynamic_single_op_reset_shape_pass.cc \
     graph/passes/mark_agnostic_pass.cc \
     graph/common/omg_util.cc \
     graph/common/bcast.cc \
@@ -164,6 +165,7 @@ OMG_HOST_SRC_FILES := \
     host_kernels/slice_d_kernel.cc \
     host_kernels/dynamic_stitch_kernel.cc \
     host_kernels/identity_kernel.cc \
+    host_kernels/reformat_kernel.cc \
     graph/passes/stop_gradient_pass.cc \
     graph/passes/prevent_gradient_pass.cc \
     graph/passes/identity_pass.cc \

ge/ge_local_engine/CMakeLists.txt

@@ -203,6 +203,7 @@ target_compile_options(ge_local_opskernel_builder_static PRIVATE
 
 target_compile_definitions(ge_local_opskernel_builder_static PRIVATE
     google=ascend_private
+    LOG_CPP
 )
 
 target_include_directories(ge_local_opskernel_builder_static PRIVATE

ge/ge_local_engine/engine/host_cpu_engine.cc

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 #include "host_cpu_engine.h"
-#include <dlfcn.h>
 #include "graph/common/omg_util.h"
 #include "graph/utils/op_desc_utils.h"
 #include "graph/utils/tensor_adapter.h"
@@ -96,8 +95,8 @@ Status GetDataNumber(const GeTensorDesc &out_desc, uint64_t &data_num) {
 
 void HostCpuEngine::CloseSo() {
   for (auto handle : lib_handles_) {
-    if (dlclose(handle) != 0) {
-      GELOGW("failed to close handle, message: %s", dlerror());
+    if (mmDlclose(handle) != 0) {
+      GELOGW("failed to close handle, message: %s", mmDlerror());
     }
   }
   lib_handles_.clear();
@@ -323,13 +322,13 @@ Status HostCpuEngine::LoadLibs(std::vector<std::string> &lib_paths) {
 
 Status HostCpuEngine::LoadLib(const std::string &lib_path) {
   GELOGI("To invoke dlopen on lib: %s", lib_path.c_str());
-  auto handle = dlopen(lib_path.c_str(), RTLD_NOW | RTLD_GLOBAL);
+  auto handle = mmDlopen(lib_path.c_str(), MMPA_RTLD_NOW | MMPA_RTLD_GLOBAL);
   if (handle == nullptr) {
-    GELOGE(INTERNAL_ERROR, "Failed to invoke dlopen. path = %s, error = %s", lib_path.c_str(), dlerror());
+    GELOGE(INTERNAL_ERROR, "Failed to invoke dlopen. path = %s, error = %s", lib_path.c_str(), mmDlerror());
     return INTERNAL_ERROR;
   }
 
-  auto initialize = (Status (*)(const HostCpuContext &))dlsym(handle, "Initialize");
+  auto initialize = (Status (*)(const HostCpuContext &))mmDlsym(handle, "Initialize");
   if (initialize != nullptr) {
     GELOGI("Invoke function Initialize in lib: %s", lib_path.c_str());
     if (initialize(HostCpuContext()) != SUCCESS) {