!7177 mindspore cxx api for 310 inference

Merge pull request !7177 from zhoufeng/cpp-infer-310

CMakeLists.txt

@@ -69,19 +69,9 @@ include_directories(${PYTHON_INCLUDE_DIRS})
 set(MS_CCSRC_PATH ${CMAKE_SOURCE_DIR}/mindspore/ccsrc)
 set(MS_CCSRC_BUILD_PATH ${BUILD_PATH}/mindspore/mindspore/ccsrc)
 
-if (ENABLE_GE)
-    link_directories(${CMAKE_SOURCE_DIR}/third_party/ge/lib)
-elseif(ENABLE_D OR ENABLE_TESTCASES)
+if (ENABLE_D OR ENABLE_ACL OR ENABLE_TESTCASES)
     include(${CMAKE_SOURCE_DIR}/cmake/dependency_graphengine.cmake)
-endif()
-
-if (ENABLE_GE OR ENABLE_D OR ENABLE_TESTCASES)
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/graphengine/inc)
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/graphengine/inc/external)
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/graphengine/inc/framework)
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/graphengine/third_party/fwkacllib/inc)
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/graphengine/third_party/fwkacllib/inc/toolchain)
-endif()
+endif ()
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
 add_subdirectory(mindspore/ccsrc)

build.sh

@@ -23,9 +23,9 @@ usage()
 {
   echo "Usage:"
   echo "bash build.sh [-d] [-r] [-v] [-c on|off] [-t on|off] [-g on|off] [-h] [-b ge] [-m infer|train] \\"
-  echo "              [-a on|off] [-p on|off] [-i] [-L] [-R] [-D on|off] [-j[n]] [-e gpu|d|cpu] \\"
+  echo "              [-a on|off] [-p on|off] [-i] [-L] [-R] [-D on|off] [-j[n]] [-e gpu|ascend|cpu|acl] \\"
   echo "              [-P on|off] [-z [on|off]] [-M on|off] [-V 9.2|10.1] [-I arm64|arm32|x86_64] [-K] \\"
-  echo "              [-B on|off] [-w on|off] [-E] [-l on|off] [-n full|lite|off] [-T on|off] \\"
+  echo "              [-B on|off] [-E] [-l on|off] [-n full|lite|off] [-T on|off] \\"
   echo "              [-A [cpp|java|object-c] [-C on|off] [-o on|off] [-S on|off] [-k on|off] [-W sse|neon|avx|off] \\"
   echo ""
   echo "Options:"
@@ -45,7 +45,7 @@ usage()
   echo "    -i Enable increment building, default off"
   echo "    -L Enable load ANF-IR as input of 'infer', default off"
   echo "    -j[n] Set the threads when building (Default: -j8)"
-  echo "    -e Use gpu, d or cpu"
+  echo "    -e Use cpu, gpu, ascend or acl"
   echo "    -P Enable dump anf graph to file in ProtoBuffer format, default on"
   echo "    -D Enable dumping of function graph ir, default on"
   echo "    -z Compile dataset & mindrecord, default on"
@@ -55,7 +55,6 @@ usage()
   echo "    -I Enable compiling mindspore lite for arm64, arm32 or x86_64, default disable mindspore lite compilation"
   echo "    -K Compile with AKG, default on"
   echo "    -s Enable serving module, default off"
-  echo "    -w Enable acl module, default off"
   echo "    -B Enable debugger, default on"
   echo "    -E Enable IBVERBS for parameter server, default off"
   echo "    -l Compile with python dependency, default on"
@@ -225,6 +224,9 @@ checkopts()
           ENABLE_D="on"
           ENABLE_CPU="on"
           ENABLE_SERVING="on"
+        elif [[ "X$OPTARG" == "Xacl" ]]; then
+          ENABLE_SERVING="on"
+          ENABLE_ACL="on"
         elif [[ "X$OPTARG" == "Xcpu" ]]; then
           ENABLE_CPU="on"
         else

cmake/dependency_graphengine.cmake

@@ -11,7 +11,7 @@ include(${GE_SOURCE_DIR}/cmake/external_libs/onnx.cmake)
 include(${GE_SOURCE_DIR}/cmake/external_libs/securec.cmake)
 
 # for UT, find slog and error_manager from local prebuild
-if (NOT ENABLE_D)
+if (NOT ENABLE_D AND NOT ENABLE_ACL)
     set(GE_PREBUILD_PATH ${GE_SOURCE_DIR}/third_party/prebuild/${CMAKE_HOST_SYSTEM_PROCESSOR})
     find_library(slog libslog.so ${GE_PREBUILD_PATH})
     find_library(error_manager liberror_manager.so ${GE_PREBUILD_PATH})
@@ -28,6 +28,7 @@ elseif (DEFINED ENV{D_LINK_PATH})
         message(FATAL_ERROR "Running on a unsupported architecture: ${SYSTEM_TYPE}, build terminated")
     endif()
     set(GE_LIB_PATH ${GE_LIB_PATH}/${GE_SYS_ARCH})
+    find_library(c_sec libc_sec.so ${GE_LIB_PATH})
     find_library(slog libslog.so ${GE_LIB_PATH})
     find_library(mmpa libmmpa.so ${GE_LIB_PATH})
     find_library(runtime libruntime.so ${GE_LIB_PATH})
@@ -44,8 +45,8 @@ else()
     else()
         set(ASCEND_PATH /usr/local/Ascend)
     endif()
-    set(ASCEND_DRIVER_PATH ${ASCEND_PATH}/driver/lib64/common)
-    set(ASCEND_RUNTIME_PATH ${ASCEND_PATH}/fwkacllib/lib64)
+    set(ASCEND_DRIVER_PATH ${ASCEND_PATH}/driver/lib64/common ${ASCEND_PATH}/driver/lib64)
+    set(ASCEND_RUNTIME_PATH ${ASCEND_PATH}/fwkacllib/lib64 ${ASCEND_PATH}/acllib/lib64 ${ASCEND_PATH}/atc/lib64)
     find_library(c_sec libc_sec.so ${ASCEND_DRIVER_PATH})
     find_library(slog libslog.so ${ASCEND_DRIVER_PATH})
     find_library(mmpa libmmpa.so ${ASCEND_DRIVER_PATH})
@@ -76,9 +77,11 @@ string(REPLACE " -Werror" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 # force __FILE__ to show relative path of file, from source directory
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__FILE__='\"$(subst $(realpath ${CMAKE_SOURCE_DIR})/,,$(abspath $<))\"' -Wno-builtin-macro-redefined")
 add_subdirectory(${GE_SOURCE_DIR}/src/common/graph)
-if(ENABLE_D)
+if (ENABLE_ACL OR ENABLE_D)
     add_subdirectory(${GE_SOURCE_DIR}/src/ge/common)
-    add_subdirectory(${GE_SOURCE_DIR}/src/ge/ge_runtime)
-endif()
+    if (ENABLE_D)
+        add_subdirectory(${GE_SOURCE_DIR}/src/ge/ge_runtime)
+    endif ()
+endif ()
 
 set(CMAKE_CXX_FLAGS ${_ge_tmp_CMAKE_CXX_FLAGS})

cmake/mind_expression.cmake

@@ -58,13 +58,22 @@ if (ENABLE_GE)
     include_directories(${CMAKE_SOURCE_DIR}/third_party/ge/include)
     include_directories(${CMAKE_SOURCE_DIR}/third_party/ge/include/external)
     include_directories(${CMAKE_SOURCE_DIR}/third_party/ge/include/external/graph)
-elseif(ENABLE_D OR ENABLE_TESTCASES)
+    link_directories(${CMAKE_SOURCE_DIR}/third_party/ge/lib)
+elseif(ENABLE_D OR ENABLE_ACL OR ENABLE_TESTCASES)
     include_directories(${CMAKE_SOURCE_DIR}/graphengine/inc)
     include_directories(${CMAKE_SOURCE_DIR}/graphengine/inc/ops)
     include_directories(${CMAKE_SOURCE_DIR}/graphengine/inc/external)
     include_directories(${CMAKE_SOURCE_DIR}/graphengine/inc/external/graph)
 endif()
 
+if (ENABLE_GE OR ENABLE_D OR ENABLE_ACL OR ENABLE_TESTCASES)
+    include_directories(${CMAKE_SOURCE_DIR}/graphengine/inc)
+    include_directories(${CMAKE_SOURCE_DIR}/graphengine/inc/external)
+    include_directories(${CMAKE_SOURCE_DIR}/graphengine/inc/framework)
+    include_directories(${CMAKE_SOURCE_DIR}/graphengine/third_party/fwkacllib/inc)
+    include_directories(${CMAKE_SOURCE_DIR}/graphengine/third_party/fwkacllib/inc/toolchain)
+endif()
+
 if (ENABLE_MINDDATA)
     include(${CMAKE_SOURCE_DIR}/cmake/external_libs/icu4c.cmake)
     include(${CMAKE_SOURCE_DIR}/cmake/external_libs/libtiff.cmake)

cmake/options.cmake

@@ -19,6 +19,7 @@ option(ENABLE_AKG "enable akg" OFF)
 option(ENABLE_DEBUGGER "enable debugger" OFF)
 option(ENABLE_IBVERBS "enable IBVERBS for parameter server" OFF)
 option(ENABLE_PYTHON "Enable python" ON)
+option(ENABLE_ACL "enable acl" OFF)
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     if (WIN32)

cmake/package.cmake

@@ -58,6 +58,12 @@ install(
     COMPONENT mindspore
 )
 
+install(
+    TARGETS mindspore_shared_lib
+    LIBRARY DESTINATION ${INSTALL_LIB_DIR}
+    COMPONENT mindspore
+)
+
 install(
     TARGETS mindspore_gvar
     DESTINATION ${INSTALL_LIB_DIR}
@@ -194,7 +200,7 @@ if (ENABLE_SERVING OR ENABLE_TESTCASES)
 endif ()
 
 if (NOT ENABLE_GE)
-    if (ENABLE_D)
+    if (ENABLE_D OR ENABLE_ACL)
         if (DEFINED ENV{ASCEND_CUSTOM_PATH})
             set(ASCEND_PATH $ENV{ASCEND_CUSTOM_PATH})
         else ()
@@ -203,19 +209,26 @@ if (NOT ENABLE_GE)
         set(ASCEND_DRIVER_PATH ${ASCEND_PATH}/driver/lib64/common)
 
         install(
-            FILES
-                ${CMAKE_BINARY_DIR}/graphengine/src/common/graph/libgraph.so
-                ${CMAKE_BINARY_DIR}/graphengine/src/ge/common/libge_common.so
-                ${CMAKE_BINARY_DIR}/graphengine/src/ge/ge_runtime/libge_runtime.so
-                ${CMAKE_SOURCE_DIR}/build/graphengine/libc_sec.so
-            DESTINATION ${INSTALL_LIB_DIR}
-            COMPONENT mindspore
-        )
-        install(
-            TARGETS ms_profile
+            FILES ${CMAKE_SOURCE_DIR}/build/graphengine/libc_sec.so
             DESTINATION ${INSTALL_LIB_DIR}
             COMPONENT mindspore
         )
+
+        if (ENABLE_D)
+            install(
+                TARGETS ms_profile
+                DESTINATION ${INSTALL_LIB_DIR}
+                COMPONENT mindspore
+            )
+            install(
+                FILES
+                    ${CMAKE_BINARY_DIR}/graphengine/src/common/graph/libgraph.so
+                    ${CMAKE_BINARY_DIR}/graphengine/src/ge/common/libge_common.so
+                    ${CMAKE_BINARY_DIR}/graphengine/src/ge/ge_runtime/libge_runtime.so
+                DESTINATION ${INSTALL_LIB_DIR}
+                COMPONENT mindspore
+            )
+        endif ()
     elseif (ENABLE_TESTCASES)
         install(
             FILES
@@ -287,6 +300,13 @@ if (EXISTS ${CMAKE_SOURCE_DIR}/mindspore/dataset)
     )
 endif ()
 
+## Public header files
+install(
+    DIRECTORY ${CMAKE_SOURCE_DIR}/include
+    DESTINATION ${INSTALL_BASE_DIR}
+    COMPONENT mindspore
+)
+
 if (ENABLE_SERVING)
     install(
         TARGETS ms_serving
@@ -308,8 +328,8 @@ if (ENABLE_SERVING)
     )
 
     install(
-            FILES ${LIBEVENT_LIB_LIST}
-            DESTINATION ${INSTALL_LIB_DIR}
-            COMPONENT mindspore
+        FILES ${LIBEVENT_LIB_LIST}
+        DESTINATION ${INSTALL_LIB_DIR}
+        COMPONENT mindspore
     )
 endif ()

graphengine

@@ -1 +1 @@
-Subproject commit 423c0228e8c421f2b095e40d14e9fb3b563f63aa
+Subproject commit 42d217fb8cec74b1c73685b8abe94d5f1520e9fe

include/api/cell.h

@@ -0,0 +1,113 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_CELL_H
+#define MINDSPORE_INCLUDE_API_CELL_H
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include "include/api/status.h"
+#include "include/api/types.h"
+
+namespace mindspore {
+namespace api {
+class InputAndOutput;
+using Input = InputAndOutput;
+using Output = InputAndOutput;
+
+class MS_API CellBase {
+ public:
+  CellBase() = default;
+  virtual ~CellBase() = default;
+  virtual std::vector<Output> Construct(const std::vector<Input> &inputs) { return {}; }
+  virtual std::shared_ptr<CellBase> Clone() const = 0;
+  std::vector<Output> operator()(const std::vector<Input> &inputs) const;
+};
+
+template <class T>
+class MS_API Cell : public CellBase {
+ public:
+  virtual ~Cell() = default;
+  std::shared_ptr<CellBase> Clone() const override {
+    return std::make_shared<T>(static_cast<const T&>(*this));
+  }
+};
+
+class MS_API ParameterCell final : public Cell<ParameterCell> {
+ public:
+  ParameterCell() = default;
+  ~ParameterCell() override = default;
+
+  ParameterCell(const ParameterCell &);
+  ParameterCell &operator=(const ParameterCell &);
+
+  ParameterCell(ParameterCell &&);
+  ParameterCell &operator=(ParameterCell &&);
+
+  explicit ParameterCell(const Tensor &);
+  ParameterCell &operator=(const Tensor &);
+
+  explicit ParameterCell(Tensor &&);
+  ParameterCell &operator=(Tensor &&);
+
+  Tensor GetTensor() const { return tensor_; }
+
+ private:
+  Tensor tensor_;
+};
+
+class MS_API OpCellBase : public CellBase {
+ public:
+  explicit OpCellBase(const std::string &name) : name_(name) {}
+  ~OpCellBase() override = default;
+  const std::string &GetOpType() const { return name_; }
+
+ protected:
+  std::string name_;
+};
+
+template <class T>
+class MS_API OpCell : public OpCellBase, public std::enable_shared_from_this<T> {
+ public:
+  explicit OpCell(const std::string &name) : OpCellBase(name) {}
+  ~OpCell() override = default;
+  std::shared_ptr<CellBase> Clone() const override {
+    return std::make_shared<T>(static_cast<const T&>(*this));
+  }
+};
+
+class MS_API InputAndOutput {
+ public:
+  InputAndOutput();
+  ~InputAndOutput() = default;
+
+  // no explicit
+  InputAndOutput(const Tensor &);  // NOLINT(runtime/explicit)
+  InputAndOutput(Tensor &&);  // NOLINT(runtime/explicit)
+
+  InputAndOutput(const std::shared_ptr<CellBase> &, const std::vector<InputAndOutput> &, int32_t index);
+
+  int32_t GetIndex() const { return index_; }
+  void SetIndex(int32_t index) { index_ = index; }
+
+ private:
+  std::shared_ptr<CellBase> cell_;
+  std::vector<InputAndOutput> prev_;
+  int32_t index_;
+};
+}  // namespace api
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CELL_H

include/api/model.h

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_MODEL_H
+#define MINDSPORE_INCLUDE_API_MODEL_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include "include/api/status.h"
+#include "include/api/types.h"
+
+namespace mindspore {
+namespace api {
+class ModelImpl;
+// todo: minddata c++ interface
+class DataSet {};
+class NetWork {};
+
+class MS_API Model {
+ public:
+  Model(const std::string &device_type, uint32_t device_id);
+  Model(NetWork network, const std::string &device_type, uint32_t device_id);
+  ~Model();
+  Model(const Model &) = delete;
+  void operator=(const Model &) = delete;
+
+  Status LoadModel(const Buffer &model_data, ModelType type, const std::map<std::string, std::string> &options);
+  Status LoadModel(const std::string &file_name, ModelType type, const std::map<std::string, std::string> &options);
+  Status UnloadModel();
+
+  Status Train(const DataSet &dataset, std::map<std::string, Buffer> *outputs);
+  Status Eval(const DataSet &dataset, std::map<std::string, Buffer> *outputs);
+  Status Predict(const std::map<std::string, Buffer> &inputs, std::map<std::string, Buffer> *outputs);
+  Status Predict(const std::vector<Buffer> &inputs, std::map<std::string, Buffer> *outputs);
+
+  Status GetInputsInfo(std::vector<Tensor> *tensor_list) const;
+  Status GetOutputsInfo(std::vector<Tensor> *tensor_list) const;
+
+ private:
+  std::shared_ptr<ModelImpl> impl_;
+};
+}  // namespace api
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_MODEL_H

include/api/ops/ops.h

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_OPS_OPS_H
+#define MINDSPORE_INCLUDE_API_OPS_OPS_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include "include/api/status.h"
+#include "include/api/types.h"
+#include "include/api/cell.h"
+
+namespace mindspore {
+namespace api {
+struct MS_API Conv2D : public OpCell<Conv2D> {
+  Conv2D() : OpCell("Conv2D") {}
+  ~Conv2D() override = default;
+  std::vector<Output> Construct(const std::vector<Input> &inputs) override;
+  Conv2D(int out_channel, const std::vector<int> &kernel_size, int mode = 1, const std::string &pad_mode = "valid",
+         const std::vector<int> &pad = {0, 0, 0, 0}, const std::vector<int> &stride = {1, 1, 1, 1},
+         const std::vector<int> &dilation = {1, 1, 1, 1}, int group = 1);
+
+  Output operator()(const Input &, const Input &) const;
+
+  int out_channel;
+  std::vector<int> kernel_size;
+  int mode = 1;
+  std::string pad_mode = "valid";
+  std::vector<int> pad = {0, 0, 0, 0};
+  std::vector<int> stride = {1, 1, 1, 1};
+  std::vector<int> dilation = {1, 1, 1, 1};
+  int group = 1;
+};
+}  // namespace api
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_OPS_OPS_H

include/api/serialization.h

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_SERIALIZATION_H
+#define MINDSPORE_INCLUDE_API_SERIALIZATION_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include "include/api/status.h"
+#include "include/api/types.h"
+#include "include/api/model.h"
+
+namespace mindspore {
+namespace api {
+class MS_API Serialization {
+ public:
+  static Status LoadCheckPoint(const std::string &ckpt_file, std::map<std::string, Buffer> *parameters);
+  static Status SetParameters(const std::map<std::string, Buffer> &parameters, Model *model);
+  static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data);
+  static Status ExportModel(const Model &model, ModelType model_type, const std::string &model_file);
+};
+}  // namespace api
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_SERIALIZATION_H

include/api/status.h

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_STATUS_H
+#define MINDSPORE_INCLUDE_API_STATUS_H
+
+#include <string>
+
+namespace mindspore {
+namespace api {
+enum StatusCode {
+  SUCCESS = 0,
+  FAILED,
+  INVALID_INPUTS,
+  // insert new status code here
+  UNKNOWN = 0xFFFFFFFF
+};
+
+class Status {
+ public:
+  Status() : status_code_(FAILED) {}
+  Status(enum StatusCode status_code, const std::string &status_msg = "")    // NOLINT(runtime/explicit)
+    : status_code_(status_code), status_msg_(status_msg) {}
+  ~Status() = default;
+
+  bool IsSuccess() const { return status_code_ == SUCCESS; }
+  enum StatusCode StatusCode() const { return status_code_; }
+  std::string StatusMessage() const { return status_msg_; }
+  bool operator==(const Status &other) const { return status_code_ == other.status_code_; }
+  bool operator==(enum StatusCode other_code) const { return status_code_ == other_code; }
+  bool operator!=(const Status &other) const { return status_code_ != other.status_code_; }
+  bool operator!=(enum StatusCode other_code) const { return status_code_ != other_code; }
+  operator bool() const = delete;
+
+ private:
+  enum StatusCode status_code_;
+  std::string status_msg_;
+};
+}  // namespace api
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_STATUS_H

include/api/types.h

@@ -0,0 +1,119 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_TYPES_H
+#define MINDSPORE_INCLUDE_API_TYPES_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#define MS_API __attribute__((visibility("default")))
+
+namespace mindspore {
+namespace api {
+enum ModelType {
+  kMindIR = 0,
+  kAIR = 1,
+  kOM = 2,
+  kONNX = 3,
+  // insert new data type here
+  kUnknownType = 0xFFFFFFFF
+};
+
+enum DataType {
+  kMsUnknown = 0,
+  kMsBool = 1,
+  kMsInt8 = 2,
+  kMsInt16 = 3,
+  kMsInt32 = 4,
+  kMsInt64 = 5,
+  kMsUint8 = 6,
+  kMsUint16 = 7,
+  kMsUint32 = 8,
+  kMsUint64 = 9,
+  kMsFloat16 = 10,
+  kMsFloat32 = 11,
+  kMsFloat64 = 12,
+  // insert new data type here
+  kInvalidDataType = 0xFFFFFFFF
+};
+
+class MS_API Tensor {
+ public:
+  Tensor();
+  Tensor(const std::string &name, DataType type, const std::vector<int64_t> &shape, const void *data, size_t data_len);
+  ~Tensor();
+
+  const std::string &Name() const;
+  void SetName(const std::string &name);
+
+  api::DataType DataType() const;
+  void SetDataType(api::DataType type);
+
+  const std::vector<int64_t> &Shape() const;
+  void SetShape(const std::vector<int64_t> &shape);
+
+  const void *Data() const;
+  void *MutableData();
+  size_t DataSize() const;
+
+  bool ResizeData(size_t data_len);
+  bool SetData(const void *data, size_t data_len);
+
+  int64_t ElementNum() const;
+  static int GetTypeSize(api::DataType type);
+  Tensor Clone() const;
+
+ private:
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+
+class MS_API Buffer {
+ public:
+  Buffer();
+  Buffer(const void *data, size_t data_len);
+  ~Buffer();
+
+  const void *Data() const;
+  void *MutableData();
+  size_t DataSize() const;
+
+  bool ResizeData(size_t data_len);
+  bool SetData(const void *data, size_t data_len);
+
+  Buffer Clone() const;
+
+ private:
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+
+constexpr auto kModelOptionDumpCfgPath = "mindspore.option.dump_config_file_path";
+constexpr auto kModelOptionDvppCfgPath = "mindspore.option.dvpp_config_file_path";
+constexpr auto kModelOptionInsertOpCfgPath = "mindspore.option.insert_op_config_file_path";  // aipp config file
+constexpr auto kModelOptionInputFormat = "mindspore.option.input_format";                    // nchw or nhwc
+// Mandatory while dynamic batch: e.g. "input_op_name1: n1,c2,h3,w4;input_op_name2: n4,c3,h2,w1"
+constexpr auto kModelOptionInputShape = "mindspore.option.input_shape";
+constexpr auto kModelOptionDynamicBatchSize = "mindspore.option.dynamic_batch_size";
+constexpr auto kModelOptionDynamicImageSize = "mindspore.option.dynamic_image_size";
+constexpr auto kModelOptionDynamicDims = "mindspore.option.dynamic_dims";
+constexpr auto kModelOptionSerialInput = "mindspore.option.serial_inputs_name";  // separated by ';'
+constexpr auto kModelOptionOutputNode = "mindspore.option.output_node";          // e.g. "node_name1:0;node_name2:1"
+constexpr auto kModelOptionOutputType = "mindspore.option.output_type";  // "FP32", "UINT8" or "FP16", default as "FP32"
+}  // namespace api
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_TYPES_H

mindspore/ccsrc/CMakeLists.txt

@@ -295,6 +295,9 @@ else ()
             target_link_libraries(mindspore ibverbs rdmacm)
         endif()
     endif()
+    if (ENABLE_ACL)
+        target_link_libraries(_c_expression PRIVATE graph)
+    endif ()
     target_link_libraries(_c_expression PRIVATE -Wl,--whole-archive mindspore proto_input -Wl,--no-whole-archive)
     target_link_libraries(_c_expression PRIVATE mindspore::pybind11_module)
     target_link_libraries(_c_expression PRIVATE mindspore_gvar)
@@ -359,3 +362,5 @@ if (CMAKE_SYSTEM_NAME MATCHES "Linux")
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
     set_target_properties(inference PROPERTIES MACOSX_RPATH ON)
 endif ()
+
+add_subdirectory(cxx_api)

mindspore/ccsrc/cxx_api/CMakeLists.txt

@@ -0,0 +1,62 @@
+# build mindspore_shared_lib
+set(LOAD_ONNX_SRC
+        ${CMAKE_SOURCE_DIR}/mindspore/ccsrc/utils/load_onnx/anf_converter.cc
+        ${CMAKE_SOURCE_DIR}/mindspore/ccsrc/utils/load_onnx/anf_model_parser.cc
+        )
+file(GLOB_RECURSE API_OPS_SRC ${CMAKE_CURRENT_SOURCE_DIR} "ops/*.cc")
+
+if (ENABLE_ACL)
+    file(GLOB_RECURSE API_ACL_SRC ${CMAKE_CURRENT_SOURCE_DIR} "model/acl/*.cc")
+endif ()
+
+set(MSLIB_SRC ${CMAKE_CURRENT_SOURCE_DIR}/types.cc
+              ${CMAKE_CURRENT_SOURCE_DIR}/cell.cc
+              ${CMAKE_CURRENT_SOURCE_DIR}/serialization.cc
+              ${CMAKE_CURRENT_SOURCE_DIR}/model/model.cc
+              ${API_ACL_SRC}
+              ${API_OPS_SRC}
+              ${LOAD_ONNX_SRC})
+
+add_library(mindspore_shared_lib SHARED ${MSLIB_SRC})
+set_target_properties(mindspore_shared_lib PROPERTIES OUTPUT_NAME mindspore PUBLIC_HEADER "${API_INCLUDE}")
+
+target_link_libraries(mindspore_shared_lib PRIVATE ${PYTHON_LIBRARIES} ${SECUREC_LIBRARY}
+        -Wl,--whole-archive mindspore -Wl,--no-whole-archive mindspore_gvar mindspore::protobuf)
+
+if (ENABLE_CPU)
+    target_link_libraries(mindspore_shared_lib PRIVATE mindspore::dnnl mindspore::mkldnn)
+endif ()
+
+if (USE_GLOG)
+    target_link_libraries(mindspore_shared_lib PRIVATE mindspore::glog)
+endif ()
+
+if (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    target_link_options(mindspore_shared_lib PRIVATE -Wl,-init,common_log_init)
+endif ()
+
+if (ENABLE_ACL)
+    if (DEFINED ENV{ASCEND_CUSTOM_PATH})
+        set(ASCEND_PATH $ENV{ASCEND_CUSTOM_PATH})
+    else ()
+        set(ASCEND_PATH /usr/local/Ascend)
+    endif ()
+    set(ACL_LIB_DIR ${ASCEND_PATH}/acllib/)
+    set(ATLAS_ACL_LIB_DIR ${ASCEND_PATH}/ascend-toolkit/latest/acllib)
+    set(ATC_DIR ${ASCEND_PATH}/atc/)
+    set(ATLAS_ATC_DIR ${ASCEND_PATH}/ascend-toolkit/latest/atc)
+    MESSAGE("acl lib dir " ${ACL_LIB_DIR} ", atc dir " ${ATC_DIR})
+    MESSAGE("atlas acl lib dir " ${ATLAS_ACL_LIB_DIR} ", atc dir " ${ATLAS_ATC_DIR})
+
+    include_directories(${ACL_LIB_DIR}/include/)
+    include_directories(${ATLAS_ACL_LIB_DIR}/include/)
+    add_compile_definitions(ENABLE_DVPP_INTERFACE)
+    find_library(acl libascendcl.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_retr libacl_retr.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_cblas libacl_cblas.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_dvpp libacl_dvpp.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_runtime libruntime.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(ge_compiler libge_compiler.so ${ATC_DIR}/lib64 ${ATLAS_ATC_DIR}/lib64)
+    target_link_libraries(mindspore_shared_lib PRIVATE ${acl} ${acl_retr} ${acl_cblas} ${acl_dvpp} ${acl_runtime}
+                                                       ${ge_compiler} mindspore::jpeg_turbo)
+endif ()

mindspore/ccsrc/cxx_api/cell.cc

@@ -0,0 +1,63 @@
+/**
+ * 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 "include/api/cell.h"
+
+namespace mindspore::api {
+std::vector<Output> CellBase::operator()(const std::vector<Input> &inputs) const { return Clone()->Construct(inputs); }
+
+ParameterCell::ParameterCell(const ParameterCell &cell) : tensor_(cell.tensor_.Clone()) {}
+ParameterCell &ParameterCell::operator=(const ParameterCell &cell) {
+  if (&cell == this) {
+    return *this;
+  }
+  tensor_ = cell.tensor_.Clone();
+  return *this;
+}
+
+ParameterCell::ParameterCell(ParameterCell &&cell) : tensor_(cell.tensor_) {}
+
+ParameterCell &ParameterCell::operator=(ParameterCell &&cell) {
+  if (&cell == this) {
+    return *this;
+  }
+  tensor_ = cell.tensor_;
+  return *this;
+}
+
+ParameterCell::ParameterCell(const Tensor &tensor) : tensor_(tensor.Clone()) {}
+
+ParameterCell &ParameterCell::operator=(const Tensor &tensor) {
+  tensor_ = tensor.Clone();
+  return *this;
+}
+
+ParameterCell::ParameterCell(Tensor &&tensor) : tensor_(tensor) {}
+
+ParameterCell &ParameterCell::operator=(Tensor &&tensor) {
+  tensor_ = tensor;
+  return *this;
+}
+
+InputAndOutput::InputAndOutput() : cell_(nullptr), prev_(), index_(-1) {}
+
+InputAndOutput::InputAndOutput(const Tensor &tensor)
+    : cell_(std::make_shared<ParameterCell>(tensor.Clone())), prev_(), index_(-1) {}
+InputAndOutput::InputAndOutput(Tensor &&tensor) : cell_(std::make_shared<ParameterCell>(tensor)), prev_(), index_(-1) {}
+
+InputAndOutput::InputAndOutput(const std::shared_ptr<CellBase> &cell, const std::vector<InputAndOutput> &prev,
+                               int32_t index)
+    : cell_(cell), prev_(prev), index_(index) {}
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/model/acl/acl_model.cc

@@ -0,0 +1,284 @@
+/**
+ * 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 "cxx_api/model/acl/acl_model.h"
+#include <memory>
+#include "utils/context/context_extends.h"
+
+namespace mindspore::api {
+std::weak_ptr<AclModel::AclEnvGuard> AclModel::global_acl_env_;
+std::mutex AclModel::global_acl_env_mutex_;
+
+Status AclModel::InitEnv() {
+  if (init_flag_) {
+    return SUCCESS;
+  }
+
+  MS_EXCEPTION_IF_NULL(options_);
+  aclError ret;
+  {
+    std::lock_guard<std::mutex> lock(global_acl_env_mutex_);
+    acl_env_ = global_acl_env_.lock();
+    if (acl_env_ != nullptr) {
+      if (options_->dump_cfg_path.empty()) {
+        MS_LOG(INFO) << "Acl has been initialized, skip.";
+      } else {
+        MS_LOG(WARNING) << "Acl has been initialized, skip, so dump config will be ignored.";
+      }
+    } else {
+      acl_env_ = std::make_shared<AclEnvGuard>(options_->dump_cfg_path);
+      if (acl_env_->GetErrno() != ACL_ERROR_NONE) {
+        MS_LOG(ERROR) << "Execute aclInit Failed";
+        return FAILED;
+      }
+      global_acl_env_ = acl_env_;
+      MS_LOG(INFO) << "Acl init success";
+    }
+  }
+
+  ret = aclrtSetDevice(device_id_);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Acl open device " << device_id_ << " failed";
+    return FAILED;
+  }
+  MS_LOG(INFO) << "Open device " << device_id_ << " success";
+
+  ret = aclrtCreateContext(&context_, device_id_);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Acl create context failed";
+    return FAILED;
+  }
+  MS_LOG(INFO) << "Create context success";
+
+  ret = aclrtSetCurrentContext(context_);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Acl set current context failed";
+    return FAILED;
+  }
+  MS_LOG(INFO) << "Set context success";
+
+  ret = aclrtCreateStream(&stream_);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Acl create stream failed";
+    return FAILED;
+  }
+  MS_LOG(INFO) << "Create stream success";
+
+  aclrtRunMode run_mode;
+  ret = aclrtGetRunMode(&run_mode);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Acl get run mode failed";
+    return FAILED;
+  }
+  bool is_device = (run_mode == ACL_DEVICE);
+  model_process_.SetIsDevice(is_device);
+  MS_LOG(INFO) << "Get run mode success is device input/output " << is_device;
+
+  if (dvpp_process_.InitResource(stream_) != SUCCESS) {
+    MS_LOG(ERROR) << "DVPP init resource failed";
+    return FAILED;
+  }
+  ModelConverter::RegAllOp();
+
+  MS_LOG(INFO) << "Init acl success, device id " << device_id_;
+  init_flag_ = true;
+  return SUCCESS;
+}
+
+Status AclModel::FinalizeEnv() {
+  if (!init_flag_) {
+    return SUCCESS;
+  }
+
+  dvpp_process_.Finalize();
+  aclError ret;
+  if (stream_ != nullptr) {
+    ret = aclrtDestroyStream(stream_);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Destroy stream failed";
+    }
+    stream_ = nullptr;
+  }
+  MS_LOG(INFO) << "End to destroy stream";
+  if (context_ != nullptr) {
+    ret = aclrtDestroyContext(context_);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Destroy context failed";
+    }
+    context_ = nullptr;
+  }
+  MS_LOG(INFO) << "End to destroy context";
+
+  ret = aclrtResetDevice(device_id_);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Reset devie " << device_id_ << " failed";
+  }
+  MS_LOG(INFO) << "End to reset device " << device_id_;
+
+  init_flag_ = false;
+  return SUCCESS;
+}
+
+Status AclModel::LoadModel(const Buffer &model_data, ModelType type,
+                           const std::map<std::string, std::string> &options) {
+  if (load_flag_) {
+    MS_LOG(ERROR) << "Model has been loaded.";
+    return FAILED;
+  }
+
+  options_ = std::make_unique<AclModelOptions>(options);
+  MS_EXCEPTION_IF_NULL(options_);
+
+  Status ret = InitEnv();
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "InitEnv failed.";
+    return FAILED;
+  }
+
+  Buffer om_data;
+  if (type == ModelType::kMindIR) {
+    model_converter_.set_options(options_.get());
+    om_data = model_converter_.LoadMindIR(model_data);
+  } else if (type == ModelType::kAIR) {
+    model_converter_.set_options(options_.get());
+    om_data = model_converter_.LoadAscendIR(model_data);
+  } else if (type == ModelType::kOM) {
+    om_data = model_data;
+  } else {
+    MS_LOG(ERROR) << "Unsupported model type " << type;
+    return FAILED;
+  }
+
+  // acl load model
+  uint32_t acl_model_id;
+  auto acl_ret = aclmdlLoadFromMem(om_data.Data(), om_data.DataSize(), &acl_model_id);
+  if (acl_ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Call aclmdlLoadFromMem failed.";
+    return FAILED;
+  }
+
+  // acl init model resource
+  model_process_.set_model_id(acl_model_id);
+  ret = model_process_.PreInitModelResource();
+  if (ret != SUCCESS) {
+    (void)aclmdlUnload(acl_model_id);
+    MS_LOG(ERROR) << "Pre init model resource failed.";
+    return FAILED;
+  }
+
+  // acl init dvpp
+  ret = dvpp_process_.InitWithJsonConfig(options_->dvpp_cfg_path);
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "DVPP config file parse error.";
+    return FAILED;
+  }
+
+  load_flag_ = true;
+  return SUCCESS;
+}
+
+Status AclModel::LoadModel(const std::string &file_name, ModelType type,
+                           const std::map<std::string, std::string> &options) {
+  Buffer model_data = ModelConverter::ReadFile(file_name);
+  if (model_data.DataSize() == 0) {
+    MS_LOG(ERROR) << "Read file " << file_name << " failed.";
+    return FAILED;
+  }
+
+  return LoadModel(model_data, type, options);
+}
+
+Status AclModel::UnloadModel() {
+  if (!load_flag_) {
+    MS_LOG(WARNING) << "No model is loaded, skip unload.";
+    return SUCCESS;
+  }
+
+  aclError rt_ret = aclrtSetCurrentContext(context_);
+  if (rt_ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Set the ascend device context failed";
+    return FAILED;
+  }
+
+  Status ret = model_process_.UnLoad();
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "Unload model inner failed.";
+    return FAILED;
+  }
+
+  ret = FinalizeEnv();
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "FinalizeEnv failed.";
+    return FAILED;
+  }
+
+  MS_LOG(INFO) << "Unload model success.";
+  load_flag_ = false;
+  return SUCCESS;
+}
+
+Status AclModel::Train(const DataSet &, std::map<std::string, Buffer> *) {
+  MS_LOG(ERROR) << "Unsupported feature.";
+  return FAILED;
+}
+
+Status AclModel::Eval(const DataSet &, std::map<std::string, Buffer> *) {
+  MS_LOG(ERROR) << "Unsupported feature.";
+  return FAILED;
+}
+
+Status AclModel::Predict(const std::map<std::string, Buffer> &inputs, std::map<std::string, Buffer> *outputs) {
+  MS_EXCEPTION_IF_NULL(outputs);
+  if (!load_flag_) {
+    MS_LOG(ERROR) << "No model is loaded, predict failed.";
+    return FAILED;
+  }
+
+  aclError rt_ret = aclrtSetCurrentContext(context_);
+  if (rt_ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Set the ascend device context failed";
+    return FAILED;
+  }
+  return model_process_.Predict(inputs, outputs);
+}
+
+Status AclModel::GetInputsInfo(std::vector<Tensor> *tensor_list) const {
+  MS_EXCEPTION_IF_NULL(tensor_list);
+  return model_process_.GetInputsInfo(tensor_list);
+}
+
+Status AclModel::GetOutputsInfo(std::vector<Tensor> *tensor_list) const {
+  MS_EXCEPTION_IF_NULL(tensor_list);
+  return model_process_.GetOutputsInfo(tensor_list);
+}
+
+AclModel::AclEnvGuard::AclEnvGuard(const std::string &cfg_file) {
+  errno_ = aclInit(common::SafeCStr(cfg_file));
+  if (errno_ != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Execute aclInit Failed";
+    return;
+  }
+  MS_LOG(INFO) << "Acl init success";
+}
+
+AclModel::AclEnvGuard::~AclEnvGuard() {
+  errno_ = aclFinalize();
+  if (errno_ != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Finalize acl failed";
+  }
+  MS_LOG(INFO) << "Acl finalize success";
+}
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/model/acl/acl_model.h

@@ -0,0 +1,99 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_CCSRC_CXX_API_ACL_MODEL_H
+#define MINDSPORE_CCSRC_CXX_API_ACL_MODEL_H
+
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <memory>
+#include <map>
+
+#include "ir/anf.h"
+#include "include/api/status.h"
+#include "cxx_api/model/model_impl.h"
+#include "cxx_api/model/acl/dvpp_process.h"
+#include "cxx_api/model/acl/model_process.h"
+#include "cxx_api/model/acl/model_converter.h"
+#include "cxx_api/model/acl/acl_model_options.h"
+#include "ir/tensor.h"
+
+namespace mindspore::api {
+class AclModel : public ModelImpl {
+ public:
+  explicit AclModel(uint32_t device_id)
+      : init_flag_(false),
+        load_flag_(false),
+        device_type_("AscendCL"),
+        device_id_(device_id),
+        context_(nullptr),
+        stream_(nullptr),
+        acl_env_(nullptr),
+        model_process_(),
+        dvpp_process_(),
+        model_converter_(),
+        options_(nullptr) {}
+  ~AclModel() = default;
+
+  Status LoadModel(const Buffer &model_data, ModelType type,
+                   const std::map<std::string, std::string> &options) override;
+  Status LoadModel(const std::string &file_name, ModelType type,
+                   const std::map<std::string, std::string> &options) override;
+  Status UnloadModel() override;
+
+  Status Train(const DataSet &dataset, std::map<std::string, Buffer> *outputs) override;
+  Status Eval(const DataSet &dataset, std::map<std::string, Buffer> *outputs) override;
+  Status Predict(const std::map<std::string, Buffer> &inputs, std::map<std::string, Buffer> *outputs) override;
+
+  Status GetInputsInfo(std::vector<Tensor> *tensor_list) const override;
+  Status GetOutputsInfo(std::vector<Tensor> *tensor_list) const override;
+
+ private:
+  bool init_flag_;
+  bool load_flag_;
+  std::string device_type_;
+  int32_t device_id_;
+  aclrtContext context_;
+  aclrtStream stream_;
+
+  class AclEnvGuard;
+  std::shared_ptr<AclEnvGuard> acl_env_;
+  static std::weak_ptr<AclEnvGuard> global_acl_env_;
+  static std::mutex global_acl_env_mutex_;
+
+  ModelProcess model_process_;
+  DvppProcess dvpp_process_;
+  ModelConverter model_converter_;
+  std::unique_ptr<AclModelOptions> options_;
+
+  Status InitEnv();
+  Status FinalizeEnv();
+};
+
+class AclModel::AclEnvGuard {
+ public:
+  explicit AclEnvGuard(const std::string &cfg_file);
+  ~AclEnvGuard();
+  aclError GetErrno() const { return errno_; }
+
+ private:
+  aclError errno_;
+};
+
+API_REG_MODEL(AscendCL, AclModel);
+}  // namespace mindspore::api
+#endif  // MINDSPORE_CCSRC_CXX_API_ACL_MODEL_H

mindspore/ccsrc/cxx_api/model/acl/acl_model_options.cc

@@ -0,0 +1,66 @@
+/**
+ * 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 "cxx_api/model/acl/acl_model_options.h"
+#include <memory>
+#include "external/ge/ge_api_types.h"
+
+namespace mindspore::api {
+static std::string ParseOption(const std::map<std::string, std::string> &options, const std::string &key) {
+  auto iter = options.find(key);
+  if (iter != options.end()) {
+    return iter->second;
+  }
+  return "";
+}
+
+AclModelOptions::AclModelOptions(const std::map<std::string, std::string> &options) {
+  dump_cfg_path = ParseOption(options, kModelOptionDumpCfgPath);
+  dvpp_cfg_path = ParseOption(options, kModelOptionDvppCfgPath);
+  output_node = ParseOption(options, kModelOptionOutputNode);
+  // to acl
+  insert_op_cfg_path = ParseOption(options, kModelOptionInsertOpCfgPath);
+  input_format = ParseOption(options, kModelOptionInputFormat);
+  input_shape = ParseOption(options, kModelOptionInputShape);
+  dynamic_batch_size = ParseOption(options, kModelOptionInputShape);
+  dynamic_image_size = ParseOption(options, kModelOptionInputShape);
+  dynamic_dims = ParseOption(options, kModelOptionInputShape);
+  serial_nodes_name = ParseOption(options, kModelOptionSerialInput);
+  output_type = ParseOption(options, kModelOptionOutputType);
+}
+
+std::map<std::string, std::string> AclModelOptions::GenAclOptions() const {
+  const std::map<std::string const *, std::string> acl_options_map = {
+    {&insert_op_cfg_path, ge::ir_option::INSERT_OP_FILE},
+    {&input_format, ge::ir_option::INPUT_FORMAT},
+    {&input_shape, ge::ir_option::INPUT_SHAPE},
+    {&dynamic_batch_size, ge::ir_option::DYNAMIC_BATCH_SIZE},
+    {&dynamic_image_size, ge::ir_option::DYNAMIC_IMAGE_SIZE},
+    {&dynamic_dims, ge::ir_option::DYNAMIC_DIMS},
+    {&serial_nodes_name, ge::ir_option::INPUT_FP16_NODES},
+    {&output_type, ge::ir_option::OUTPUT_TYPE},
+  };
+
+  std::map<std::string, std::string> acl_options;
+  for (auto [ms_option, acl_option_key] : acl_options_map) {
+    if (ms_option == nullptr || ms_option->empty()) {
+      continue;
+    }
+    acl_options.emplace(acl_option_key, *ms_option);
+  }
+  return acl_options;
+}
+
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/model/acl/acl_model_options.h

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_OPTION_PARSER_H
+#define MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_OPTION_PARSER_H
+#include <vector>
+#include <string>
+#include <map>
+#include "include/api/types.h"
+#include "include/api/status.h"
+
+namespace mindspore::api {
+struct AclModelOptions {
+  std::string dump_cfg_path;
+  std::string dvpp_cfg_path;
+  std::string output_node;  // todo: at convert.cc::BuildGraph(), no atc options
+  // build options
+  std::string insert_op_cfg_path;
+  std::string input_format;
+  std::string input_shape;
+  std::string dynamic_batch_size;
+  std::string dynamic_image_size;
+  std::string dynamic_dims;
+  std::string serial_nodes_name;
+  std::string output_type;
+
+  explicit AclModelOptions(const std::map<std::string, std::string> &options);
+  ~AclModelOptions() = default;
+
+  std::map<std::string, std::string> GenAclOptions() const;
+};
+}  // namespace mindspore::api
+
+#endif  // MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_OPTION_PARSER_H

mindspore/ccsrc/cxx_api/model/acl/dvpp_process.h

@@ -0,0 +1,160 @@
+/**
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_DVPP_PROCESS_H
+#define MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_DVPP_PROCESS_H
+#include <vector>
+#include <string>
+#include <map>
+#include "acl/acl.h"
+#include "acl/acl_mdl.h"
+#include "acl/acl_rt.h"
+#include "acl/ops/acl_dvpp.h"
+#include "include/api/status.h"
+
+namespace mindspore::api {
+struct DvppDecodePara {
+  acldvppPixelFormat pixel_format = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
+};
+
+struct DvppResizePara {
+  uint32_t output_width = 0;
+  uint32_t output_height = 0;
+};
+
+enum DvppCropType {
+  // crop left,top,right,bottom is given in config
+  kDvppCropTypeOffset = 0,
+  // crop left,top,right,bottom is calculated by image width/height and output crop width/height
+  kDvppCropTypeCentre = 1,
+};
+
+struct DvppRoiArea {
+  uint32_t left = 0;
+  uint32_t top = 0;
+  uint32_t right = 0;
+  uint32_t bottom = 0;
+};
+
+struct DvppCropInfo {
+  DvppCropType crop_type = kDvppCropTypeOffset;
+  DvppRoiArea crop_area;     // when kDvppCropTypeOffset
+  uint32_t crop_width = 0;   // when kDvppCropTypeCentre
+  uint32_t crop_height = 0;  // when kDvppCropTypeCentre
+};
+
+struct DvppCropPara {
+  DvppCropInfo crop_info;
+  uint32_t output_width = 0;
+  uint32_t output_height = 0;
+};
+
+struct DvppCropAndPastePara {
+  DvppCropInfo crop_info;
+  DvppRoiArea paste_area;
+  uint32_t output_width = 0;
+  uint32_t output_height = 0;
+};
+
+class DvppProcess {
+ public:
+  DvppProcess();
+  ~DvppProcess();
+
+  Status InitResource(aclrtStream stream);
+  void Finalize();
+  Status InitJpegDecodePara(const DvppDecodePara &decode_para);                  // jpeg decode + (resize | crop)
+  Status InitResizePara(const DvppResizePara &resize_para);                      // jpeg decode + resize
+  Status InitCropPara(const DvppCropPara &crop_para);                            // jpeg decode + crop
+  Status InitCropAndPastePara(const DvppCropAndPastePara &crop_and_paste_para);  // jpeg decode + crop&paste
+
+  Status InitWithJsonConfig(const std::string &json_config);
+
+  // output device buffer will be destroy by DvppProcess itself.
+  Status Process(const void *pic_buffer, size_t pic_buffer_size, void **output_device_buffer, size_t *output_size);
+  Status Process(const std::vector<const void *> &pic_buffer_list, const std::vector<size_t> &pic_buffer_size_list,
+                 void **output_device_buffer, size_t *output_size);
+  bool HasLoaded() const { return loaded_flag_; }
+
+ private:
+  bool loaded_flag_ = false;
+  uint32_t pic_width_ = 0;
+  uint32_t pic_height_ = 0;
+
+  DvppDecodePara decode_para_;
+  DvppResizePara resize_para_;
+  DvppCropPara crop_para_;
+  DvppCropAndPastePara crop_and_paste_para_;
+  // only one of the resize or crop flag can be true
+  bool to_resize_flag_ = false;
+  bool to_crop_flag_ = false;
+  bool to_crop_and_paste_flag_ = false;
+
+  void *input_pic_dev_buffer_ = nullptr;
+  uint32_t input_pic_buffer_size_ = 0;
+
+  uint32_t decode_output_buffer_size_ = 0;
+  void *decode_output_buffer_dev_ = nullptr;
+  acldvppPicDesc *decode_output_desc_ = nullptr;
+
+  acldvppResizeConfig *resize_config_ = nullptr;
+  acldvppRoiConfig *crop_area_ = nullptr;
+  acldvppRoiConfig *paste_area_ = nullptr;
+
+  acldvppPicDesc *vpc_output_desc_ = nullptr;
+  void *vpc_output_buffer_dev_ = nullptr;  // vpc_output_buffer_size_ length
+  uint32_t vpc_output_buffer_size_ = 0;
+
+  void *batch_vpc_output_buffer_dev_ = nullptr;  // batch_size_ * vpc_output_buffer_size_ length
+  uint32_t batch_size_ = 0;
+
+  aclrtStream stream_ = nullptr;
+  acldvppChannelDesc *dvpp_channel_desc_ = nullptr;
+
+  uint32_t AlignmentHelper(uint32_t org_size, uint32_t alignment) const;
+  uint32_t GetImageBufferSize(uint32_t stride_width, uint32_t stride_height, acldvppPixelFormat pixel_format) const;
+  Status GetPicDescStride(uint32_t width, uint32_t height, uint32_t *stride_width, uint32_t *stride_height);
+  Status GetPicDescStrideDecode(uint32_t width, uint32_t height, uint32_t *stride_width, uint32_t *stride_height);
+  Status InputInputBuffer(const void *pic_buffer, size_t pic_buffer_size);
+  Status InitDecodeOutputDesc(uint32_t image_width,
+                              uint32_t image_height);  // decode_output_desc_, decode_output_buffer_dev_
+  Status CheckRoiAreaWidthHeight(uint32_t width, uint32_t height);
+  Status CheckAndAdjustRoiArea(DvppRoiArea *area);
+  Status UpdateCropArea(uint32_t image_width, uint32_t image_height);
+  Status CheckResizeImageInfo(uint32_t image_width, uint32_t image_height) const;
+  void DestroyDecodeDesc();
+
+  Status InitVpcOutputDesc(uint32_t output_width, uint32_t output_height,
+                           acldvppPixelFormat pixel_format);  // vpc_output_desc_, vpc_output_buffer_dev_batch_
+  Status InitRoiAreaConfig(const DvppRoiArea &init_para, acldvppRoiConfig **roi_area);
+  Status InitCommonCropPara(uint32_t out_width, uint32_t out_height, DvppCropInfo *crop_info);
+  Status InitResizeOutputDesc();        // vpc_output_desc_, vpc_output_buffer_dev_, resize_config
+  Status InitCropOutputDesc();          // vpc_output_desc_, vpc_output_buffer_dev_, crop_area_
+  Status InitCropAndPasteOutputDesc();  // vpc_output_desc_, vpc_output_buffer_dev_, crop_area_, paste_area_
+  void DestroyVpcOutputDesc();
+
+  Status ProcessDecode();
+  Status ProcessResize();
+  Status ProcessCrop();
+  Status ProcessCropAndPaste();
+  void DestroyResource();
+
+  Status GetJpegWidthHeight(const void *pic_buffer, size_t pic_buffer_size, uint32_t *image_width,
+                            uint32_t *image_height);
+};
+}  // namespace mindspore::api
+
+#endif  // MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_DVPP_PROCESS_H

mindspore/ccsrc/cxx_api/model/acl/model_converter.cc

@@ -0,0 +1,285 @@
+/**
+ * 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 "cxx_api/model/acl/model_converter.h"
+#include <memory>
+#include "pybind11/pybind11.h"
+#include "utils/load_onnx/anf_converter.h"
+#include "transform/graph_ir/convert.h"
+#include "transform/graph_ir/graph_runner.h"
+#include "mindspore/core/utils/ms_context.h"
+#include "backend/kernel_compiler/oplib/oplib.h"
+
+#include "graph/model.h"
+
+namespace py = pybind11;
+
+namespace mindspore::api {
+namespace {
+transform::TensorOrderMap GetParams(const FuncGraphPtr &anf_graph) {
+  transform::TensorOrderMap res;
+  for (auto &anf_node : anf_graph->parameters()) {
+    MS_EXCEPTION_IF_NULL(anf_node);
+    auto para = anf_node->cast<ParameterPtr>();
+    MS_EXCEPTION_IF_NULL(para);
+    if (para->has_default()) {
+      auto value = para->default_param();
+      MS_EXCEPTION_IF_NULL(value);
+      auto tensor = value->cast<std::shared_ptr<tensor::Tensor>>();
+      res.emplace(para->name(), tensor);
+      MS_LOG(INFO) << "Parameter " << para->name() << " has default value.";
+    }
+  }
+  return res;
+}
+
+bool CreateSessionAndGraphRunner() {
+  std::shared_ptr<ge::Session> sess = transform::DfGraphManager::GetInstance().GetGeSession();
+  if (sess == nullptr) {
+    transform::SessionOptions options;
+    options["ge.trainFlag"] = "0";
+    options["ge.enablePrintOpPass"] = "0";
+    sess = transform::GraphRunner::NewSession(options);
+    if (sess == nullptr) {
+      MS_LOG(ERROR) << "Init data graph failed, because of create Ge session failed";
+      return false;
+    } else {
+      transform::DfGraphManager::GetInstance().SetGeSession(sess);
+    }
+  }
+
+  transform::GraphRunnerOptions options;
+  options.sess_ptr = sess;
+  auto graph_runner = std::make_shared<transform::GraphRunner>(options);
+  if (graph_runner == nullptr) {
+    MS_LOG(ERROR) << "Create new graph runner failed";
+    return false;
+  } else {
+    transform::DfGraphManager::GetInstance().SetGraphRunner(graph_runner);
+  }
+
+  return true;
+}
+
+}  // namespace
+
+std::shared_ptr<FuncGraph> ModelConverter::ConvertMindIrToFuncGraph(const Buffer &model_data) {
+  try {
+    auto anf_graph =
+      lite::AnfConverter::RunAnfConverter(reinterpret_cast<const char *>(model_data.Data()), model_data.DataSize());
+    return anf_graph;
+  } catch (std::exception &e) {
+    MS_LOG(ERROR) << "Load MindIR failed.";
+    return nullptr;
+  }
+}
+
+transform::DfGraphPtr ModelConverter::ConvertFuncGraphToAIR(const FuncGraphPtr &anf_graph) {
+  for (auto &anf_node : anf_graph->parameters()) {
+    MS_EXCEPTION_IF_NULL(anf_node);
+    auto para = anf_node->cast<ParameterPtr>();
+    MS_EXCEPTION_IF_NULL(para);
+    // normalize name
+    std::string name = para->name();
+    for (auto pos = name.find(':'); pos != std::string::npos; pos = name.find(':')) {
+      name = name.substr(0, pos) + "_" + name.substr(pos + 1);
+      MS_LOG(INFO) << name;
+    }
+    para->set_name(name);
+  }
+
+  transform::DfGraphConvertor convertor(anf_graph);
+  std::string net_id = "0";
+  std::string init_graph = "init_subgraph." + net_id;
+  std::string checkpoint_name = "save." + net_id;
+
+  convertor.set_training(false);
+  (void)convertor.ConvertAllNode().InitParam(GetParams(anf_graph)).BuildGraph();
+  (void)convertor.GenerateCheckpointGraph();
+  if (convertor.ErrCode() != 0) {
+    transform::DfGraphManager::GetInstance().ClearGraph();
+    MS_LOG(ERROR) << "Convert df graph failed, err:" << convertor.ErrCode();
+    return nullptr;
+  }
+  (void)transform::DfGraphManager::GetInstance().AddGraph(anf_graph->ToString(), convertor.GetComputeGraph());
+  (void)transform::DfGraphManager::GetInstance().AddGraph(init_graph, convertor.GetInitGraph());
+  (void)transform::DfGraphManager::GetInstance().AddGraph(BROADCAST_GRAPH_NAME, convertor.GetBroadcastGraph());
+
+  transform::Status ret =
+    transform::DfGraphManager::GetInstance().AddGraph(checkpoint_name, convertor.GetSaveCheckpointGraph());
+  if (ret == transform::Status::SUCCESS) {
+    transform::DfGraphManager::GetInstance().SetAnfGraph(checkpoint_name, anf_graph);
+  }
+
+  (void)setenv("GE_TRAIN", "0", 1);
+
+  if (!CreateSessionAndGraphRunner()) {
+    MS_LOG(ERROR) << "Create GE Session or GraphRunner failed.";
+    return nullptr;
+  }
+
+  auto wrap_ptr = transform::DfGraphManager::GetInstance().GetGraphByName(anf_graph->ToString());
+  if (wrap_ptr == nullptr) {
+    MS_LOG(ERROR) << "Get graph form DfGraphManager failed!";
+    return nullptr;
+  }
+  transform::DfGraphPtr &ge_graph = wrap_ptr->graph_ptr_;
+  if (ge_graph == nullptr) {
+    MS_LOG(ERROR) << "The export graph is null";
+    return nullptr;
+  }
+
+  return ge_graph;
+}
+
+Buffer ModelConverter::BuildAirModel(const transform::DfGraphPtr &graph,
+                                     const std::map<std::string, std::string> &acl_options) {
+  ge::ModelBufferData model;
+  auto ge_options = acl_options;
+  ge_options.emplace(ge::ir_option::SOC_VERSION, "Ascend310");
+  auto ret = ge::aclgrphBuildInitialize(ge_options);
+  if (ret != ge::SUCCESS) {
+    MS_LOG(ERROR) << "Call aclgrphBuildInitialize fail.";
+    return Buffer();
+  }
+
+  ret = ge::aclgrphBuildModel(*graph, acl_options, model);
+  if (ret != ge::SUCCESS) {
+    MS_LOG(ERROR) << "Call aclgrphBuildModel fail.";
+    return Buffer();
+  }
+
+  ge::aclgrphBuildFinalize();
+  return Buffer(model.data.get(), model.length);
+}
+
+void ModelConverter::RegAllOp() {
+  static std::mutex init_mutex;
+  static bool Initialized = false;
+
+  std::lock_guard<std::mutex> lock(init_mutex);
+  if (Initialized) {
+    return;
+  }
+  Initialized = true;
+  MsContext::GetInstance()->set_param<int>(MS_CTX_EXECUTION_MODE, kGraphMode);
+  Py_Initialize();
+  auto c_expression = PyImport_ImportModule("mindspore._c_expression");
+  MS_EXCEPTION_IF_NULL(c_expression);
+  PyObject *c_expression_dict = PyModule_GetDict(c_expression);
+  MS_EXCEPTION_IF_NULL(c_expression_dict);
+
+  PyObject *op_info_loader_class = PyDict_GetItemString(c_expression_dict, "OpInfoLoaderPy");
+  MS_EXCEPTION_IF_NULL(op_info_loader_class);
+  PyObject *op_info_loader = PyInstanceMethod_New(op_info_loader_class);
+  MS_EXCEPTION_IF_NULL(op_info_loader);
+  PyObject *op_info_loader_ins = PyObject_CallObject(op_info_loader, nullptr);
+  MS_EXCEPTION_IF_NULL(op_info_loader_ins);
+  auto all_ops_info_vector_addr_ul = PyObject_CallMethod(op_info_loader_ins, "get_all_ops_info", nullptr);
+  MS_EXCEPTION_IF_NULL(all_ops_info_vector_addr_ul);
+  auto all_ops_info_vector_addr = PyLong_AsVoidPtr(all_ops_info_vector_addr_ul);
+  auto all_ops_info = static_cast<std::vector<kernel::OpInfo *> *>(all_ops_info_vector_addr);
+  for (auto op_info : *all_ops_info) {
+    kernel::OpLib::RegOpInfo(std::shared_ptr<kernel::OpInfo>(op_info));
+  }
+  all_ops_info->clear();
+  delete all_ops_info;
+  Py_DECREF(op_info_loader);
+  Py_DECREF(op_info_loader_class);
+  Py_DECREF(c_expression_dict);
+  Py_DECREF(c_expression);
+}
+
+Buffer ModelConverter::ReadFile(const std::string &file) {
+  Buffer buffer;
+  if (file.empty()) {
+    MS_LOG(ERROR) << "Pointer file is nullptr";
+    return buffer;
+  }
+  std::string realPath = file;
+  std::ifstream ifs(realPath);
+  if (!ifs.good()) {
+    MS_LOG(ERROR) << "File: " << realPath << " is not exist";
+    return buffer;
+  }
+
+  if (!ifs.is_open()) {
+    MS_LOG(ERROR) << "File: " << realPath << "open failed";
+    return buffer;
+  }
+
+  ifs.seekg(0, std::ios::end);
+  size_t size = ifs.tellg();
+  buffer.ResizeData(size);
+  if (buffer.DataSize() != size) {
+    MS_LOG(ERROR) << "Malloc buf failed, file: " << realPath;
+    ifs.close();
+    return buffer;
+  }
+
+  ifs.seekg(0, std::ios::beg);
+  ifs.read(reinterpret_cast<char *>(buffer.MutableData()), size);
+  ifs.close();
+
+  return buffer;
+}
+
+Buffer ModelConverter::LoadMindIR(const Buffer &model_data) {
+  auto func_graph = ConvertMindIrToFuncGraph(model_data);
+  if (func_graph == nullptr) {
+    MS_LOG(ERROR) << "Convert MindIR to FuncGraph failed.";
+    return Buffer();
+  }
+
+  auto df_graph = ConvertFuncGraphToAIR(func_graph);
+  if (df_graph == nullptr) {
+    MS_LOG(ERROR) << "Convert FuncGraph to AscendIR failed.";
+    return Buffer();
+  }
+
+  std::map<std::string, std::string> acl_options;
+  if (options_ != nullptr) {
+    acl_options = options_->GenAclOptions();
+  }
+
+  auto om_data = BuildAirModel(df_graph, acl_options);
+  return om_data;
+}
+
+Buffer ModelConverter::LoadAscendIR(const Buffer &model_data) {
+  ge::Model load_model = ge::Model("loadmodel", "version2");
+  ge::Status ret =
+    ge::Model::Load(reinterpret_cast<const uint8_t *>(model_data.Data()), model_data.DataSize(), load_model);
+  if (ret != ge::GRAPH_SUCCESS) {
+    MS_LOG(ERROR) << "Load AscendIR failed, ret = " << ret;
+    return Buffer();
+  }
+
+  transform::DfGraphPtr df_graph = std::make_shared<transform::DfGraph>(load_model.GetGraph());
+  if (df_graph == nullptr) {
+    MS_LOG(ERROR) << "Convert FuncGraph to AscendIR failed.";
+    return Buffer();
+  }
+
+  std::map<std::string, std::string> acl_options;
+  if (options_ != nullptr) {
+    acl_options = options_->GenAclOptions();
+  }
+
+  auto om_data = BuildAirModel(df_graph, acl_options);
+  return om_data;
+}
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/model/acl/model_converter.h

@@ -0,0 +1,51 @@
+/**
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_MODEL_CONVERTER_H
+#define MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_MODEL_CONVERTER_H
+#include <vector>
+#include <string>
+#include <map>
+#include <memory>
+#include "include/api/types.h"
+#include "include/api/status.h"
+#include "mindspore/core/ir/func_graph.h"
+#include "transform/graph_ir/types.h"
+#include "external/ge/ge_ir_build.h"
+#include "cxx_api/model/acl/acl_model_options.h"
+
+namespace mindspore::api {
+class ModelConverter {
+ public:
+  ModelConverter() : options_(nullptr) {}
+
+  Buffer LoadMindIR(const Buffer &model_data);
+  Buffer LoadAscendIR(const Buffer &model_data);
+
+  void set_options(AclModelOptions *options) { options_ = options; }
+
+  static Buffer ReadFile(const std::string &file);
+  static void RegAllOp();
+
+ private:
+  std::shared_ptr<FuncGraph> ConvertMindIrToFuncGraph(const Buffer &model_data);
+  transform::DfGraphPtr ConvertFuncGraphToAIR(const FuncGraphPtr &anf_graph);
+  Buffer BuildAirModel(const transform::DfGraphPtr &graph, const std::map<std::string, std::string> &acl_options);
+  AclModelOptions *options_;
+};
+}  // namespace mindspore::api
+
+#endif  // MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_MODEL_CONVERTER_H

mindspore/ccsrc/cxx_api/model/acl/model_process.cc

@@ -0,0 +1,440 @@
+/**
+ * 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 "cxx_api/model/acl/model_process.h"
+#include <algorithm>
+#include <map>
+#include "utils/utils.h"
+
+namespace mindspore::api {
+static DataType TransToApiType(aclDataType data_type) {
+  static const std::map<aclDataType, api::DataType> data_type_map = {
+    {ACL_FLOAT16, api::kMsFloat16}, {ACL_FLOAT, api::kMsFloat32}, {ACL_DOUBLE, api::kMsFloat64},
+    {ACL_INT8, api::kMsInt8},       {ACL_INT16, api::kMsInt16},   {ACL_INT32, api::kMsInt32},
+    {ACL_INT64, api::kMsInt64},     {ACL_UINT8, api::kMsUint8},   {ACL_UINT16, api::kMsUint16},
+    {ACL_UINT32, api::kMsUint32},   {ACL_UINT64, api::kMsUint64}, {ACL_BOOL, api::kMsBool},
+  };
+  auto it = data_type_map.find(data_type);
+  if (it == data_type_map.end()) {
+    return api::kInvalidDataType;
+  } else {
+    return it->second;
+  }
+}
+
+static void ConstructTensorDesc(const std::vector<AclTensorInfo> &acl_tensor_list, std::vector<Tensor> *tensor_list) {
+  MS_EXCEPTION_IF_NULL(tensor_list);
+  tensor_list->clear();
+
+  for (size_t i = 0; i < acl_tensor_list.size(); ++i) {
+    const auto &info = acl_tensor_list[i];
+    Tensor tensor_desc;
+    tensor_desc.SetName(info.name);
+    tensor_desc.SetDataType(TransToApiType(info.data_type));
+    tensor_desc.SetShape(info.dims);
+    tensor_list->push_back(tensor_desc);
+  }
+}
+
+Status ModelProcess::PreInitModelResource() {
+  model_desc_ = aclmdlCreateDesc();
+  aclError acl_ret = aclmdlGetDesc(model_desc_, model_id_);
+  if (acl_ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Read model desc failed";
+    return FAILED;
+  }
+  Status ret = InitInputsBuffer();
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "Create input buffer failed";
+    return FAILED;
+  }
+  ret = InitOutputsBuffer();
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "Create output buffer failed";
+    return FAILED;
+  }
+  return SUCCESS;
+}
+
+Status ModelProcess::LoadModelFromFile(const std::string &file_name, uint32_t *model_id) {
+  MS_EXCEPTION_IF_NULL(model_id);
+  aclError acl_ret = aclmdlLoadFromFile(file_name.c_str(), model_id);
+  if (acl_ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Read model file failed, file name is " << file_name;
+    return FAILED;
+  }
+  MS_LOG(INFO) << "Load model success " << file_name;
+  model_id_ = *model_id;
+  if (PreInitModelResource() != SUCCESS) {
+    aclmdlUnload(model_id_);
+    MS_LOG(ERROR) << "Pre init model resource failed, file name is " << file_name;
+    return FAILED;
+  }
+  return SUCCESS;
+}
+
+Status ModelProcess::InitInputsBuffer() {
+  aclError ret;
+  size_t input_size = aclmdlGetNumInputs(model_desc_);
+  MS_LOG(INFO) << "input_size = " << input_size;
+  for (size_t i = 0; i < input_size; ++i) {
+    auto buffer_size = aclmdlGetInputSizeByIndex(model_desc_, i);
+    void *data_mem_buffer = nullptr;
+    if (!is_run_on_device_) {  // need to copy input/output to/from device
+      ret = aclrtMalloc(&data_mem_buffer, buffer_size, ACL_MEM_MALLOC_NORMAL_ONLY);
+      if (ret != ACL_ERROR_NONE) {
+        MS_LOG(ERROR) << "Malloc device input buffer faild , input size " << buffer_size;
+        return FAILED;
+      }
+    }
+
+    aclmdlIODims dims;
+    ret = aclmdlGetInputDims(model_desc_, i, &dims);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Get input shape failed";
+      if (!is_run_on_device_) {
+        aclrtFree(data_mem_buffer);
+      }
+      return FAILED;
+    }
+    aclDataType data_type = aclmdlGetInputDataType(model_desc_, i);
+    std::vector<int64_t> shape(dims.dims, dims.dims + dims.dimCount);
+    std::string input_name = aclmdlGetInputNameByIndex(model_desc_, i);
+    if (input_name.empty()) {
+      MS_LOG(WARNING) << "Get name of input " << i << " failed.";
+    }
+    MS_LOG(INFO) << "Name of input " << i << " is " << input_name;
+    input_infos_.emplace_back(AclTensorInfo{data_mem_buffer, buffer_size, data_type, shape, input_name});
+  }
+  MS_LOG(INFO) << "Create model inputs success";
+  return SUCCESS;
+}
+
+Status ModelProcess::CreateDataBuffer(void **data_mem_buffer, size_t buffer_size, aclmdlDataset *dataset) {
+  MS_EXCEPTION_IF_NULL(data_mem_buffer);
+  aclError ret;
+  auto free_data_buffer = [this](void *dataMemBuffer) {
+    if (!is_run_on_device_) {
+      aclrtFree(dataMemBuffer);
+    } else {
+      aclrtFreeHost(dataMemBuffer);
+    }
+  };
+
+  if (!is_run_on_device_) {
+    ret = aclrtMalloc(data_mem_buffer, buffer_size, ACL_MEM_MALLOC_NORMAL_ONLY);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Malloc device buffer faild , buffer size " << buffer_size;
+      return FAILED;
+    }
+  } else {
+    ret = aclrtMallocHost(data_mem_buffer, buffer_size);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Malloc device buffer faild , buffer size " << buffer_size;
+      return FAILED;
+    }
+  }
+
+  auto data_buffer = aclCreateDataBuffer(*data_mem_buffer, buffer_size);
+  if (data_buffer == nullptr) {
+    MS_LOG(ERROR) << "Create Data Buffer failed";
+    free_data_buffer(*data_mem_buffer);
+    return FAILED;
+  }
+  ret = aclmdlAddDatasetBuffer(dataset, data_buffer);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "add data buffer failed";
+    free_data_buffer(*data_mem_buffer);
+    aclDestroyDataBuffer(data_buffer);
+    return FAILED;
+  }
+  return SUCCESS;
+}
+
+Status ModelProcess::InitOutputsBuffer() {
+  aclError ret;
+  outputs_ = aclmdlCreateDataset();
+  if (outputs_ == nullptr) {
+    MS_LOG(ERROR) << "Create input dataset failed";
+    return FAILED;
+  }
+  size_t output_size = aclmdlGetNumOutputs(model_desc_);
+  MS_LOG(INFO) << "output_size = " << output_size;
+  for (size_t i = 0; i < output_size; ++i) {
+    auto buffer_size = aclmdlGetOutputSizeByIndex(model_desc_, i);
+
+    void *data_mem_buffer = nullptr;
+    if (CreateDataBuffer(&data_mem_buffer, buffer_size, outputs_) != SUCCESS) {
+      MS_LOG(ERROR) << "add output data buffer failed, buffer size " << buffer_size;
+      return FAILED;
+    }
+    aclmdlIODims dims;
+    ret = aclmdlGetOutputDims(model_desc_, i, &dims);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Get input shape failed";
+      if (!is_run_on_device_) {
+        aclrtFree(data_mem_buffer);
+      } else {
+        aclrtFreeHost(data_mem_buffer);
+      }
+      return FAILED;
+    }
+    aclDataType data_type = aclmdlGetOutputDataType(model_desc_, i);
+    std::vector<int64_t> shape(dims.dims, dims.dims + dims.dimCount);
+    std::string output_name = aclmdlGetOutputNameByIndex(model_desc_, i);
+    if (output_name.empty()) {
+      MS_LOG(WARNING) << "Get name of output " << i << " failed.";
+    }
+    MS_LOG(INFO) << "Name of input " << i << " is " << output_name;
+    output_infos_.emplace_back(AclTensorInfo{data_mem_buffer, buffer_size, data_type, shape, output_name});
+  }
+  MS_LOG(INFO) << "Create model output success";
+  return SUCCESS;
+}
+
+void ModelProcess::DestroyInputsDataset() {
+  if (inputs_ == nullptr) {
+    return;
+  }
+  for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(inputs_); i++) {
+    auto dataBuffer = aclmdlGetDatasetBuffer(inputs_, i);
+    aclDestroyDataBuffer(dataBuffer);
+  }
+  aclmdlDestroyDataset(inputs_);
+  inputs_ = nullptr;
+}
+
+void ModelProcess::DestroyInputsDataMem() {
+  if (!is_run_on_device_) {
+    for (const auto &item : input_infos_) {
+      aclrtFree(item.device_data);
+    }
+  }
+  input_infos_.clear();
+}
+
+void ModelProcess::DestroyInputsBuffer() {
+  DestroyInputsDataMem();
+  DestroyInputsDataset();
+}
+
+void ModelProcess::DestroyOutputsBuffer() {
+  for (const auto &item : output_infos_) {
+    if (!is_run_on_device_) {
+      aclrtFree(item.device_data);
+    } else {
+      aclrtFreeHost(item.device_data);
+    }
+  }
+  output_infos_.clear();
+
+  if (outputs_ == nullptr) {
+    return;
+  }
+  for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(outputs_); i++) {
+    auto dataBuffer = aclmdlGetDatasetBuffer(outputs_, i);
+    aclDestroyDataBuffer(dataBuffer);
+  }
+  aclmdlDestroyDataset(outputs_);
+  outputs_ = nullptr;
+}
+
+Status ModelProcess::UnLoad() {
+  auto ret = aclmdlUnload(model_id_);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Unload model failed";
+    return FAILED;
+  }
+  if (model_desc_ != nullptr) {
+    ret = aclmdlDestroyDesc(model_desc_);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Unload model failed";
+      return FAILED;
+    }
+    model_desc_ = nullptr;
+  }
+  DestroyInputsBuffer();
+  DestroyOutputsBuffer();
+  MS_LOG(INFO) << "End unload model " << model_id_;
+  return SUCCESS;
+}
+
+Status ModelProcess::CheckAndInitInput(const std::map<std::string, Buffer> &inputs) {
+  aclError ret;
+  inputs_ = aclmdlCreateDataset();
+  // check inputs
+  if (inputs.size() != input_infos_.size()) {
+    MS_LOG(ERROR) << "inputs count not match, required count " << input_infos_.size() << ", given count "
+                  << inputs.size();
+    return INVALID_INPUTS;
+  }
+  for (size_t i = 0; i < input_infos_.size(); ++i) {
+    const std::string &input_name = input_infos_[i].name;
+    auto iter = inputs.find(input_name);
+    if (iter == inputs.end()) {
+      MS_LOG(ERROR) << "Model missing input " << input_name;
+      return INVALID_INPUTS;
+    }
+
+    if (iter->second.DataSize() != input_infos_[i].buffer_size) {
+      MS_LOG(ERROR) << "input " << i << " data size not match, required size " << input_infos_[i].buffer_size
+                    << ", given count " << iter->second.DataSize();
+      return INVALID_INPUTS;
+    }
+  }
+  // copy inputs
+  for (size_t i = 0; i < input_infos_.size(); ++i) {
+    const auto &info = input_infos_[i];
+    auto iter = inputs.find(info.name);
+    if (iter == inputs.end()) {
+      MS_LOG(ERROR) << "Model missing input " << info.name;
+      return INVALID_INPUTS;
+    }
+
+    const auto &input = iter->second;
+    const void *data = input.Data();
+
+    void *input_buffer;
+    if (!is_run_on_device_) {
+      ret = aclrtMemcpy(info.device_data, info.buffer_size, data, input.DataSize(), ACL_MEMCPY_HOST_TO_DEVICE);
+      if (ret != ACL_ERROR_NONE) {
+        MS_LOG(ERROR) << "Acl memcpy input " << i << " data to device failed, buffer size " << input.DataSize();
+        return FAILED;
+      }
+      input_buffer = info.device_data;
+    } else {
+      input_buffer = const_cast<void *>(data);
+    }
+    auto data_buffer = aclCreateDataBuffer(input_buffer, info.buffer_size);
+    if (data_buffer == nullptr) {
+      MS_LOG(ERROR) << "Create Data Buffer failed";
+      return FAILED;
+    }
+    ret = aclmdlAddDatasetBuffer(inputs_, data_buffer);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "add data buffer failed";
+      aclDestroyDataBuffer(data_buffer);
+      return FAILED;
+    }
+  }
+  return SUCCESS;
+}
+
+Status ModelProcess::CheckAndInitDvppInput(const void *dvpp_outputs_buffer_dev, size_t dvpp_outputs_buffer_size,
+                                           size_t input_index) {
+  aclError ret;
+  inputs_ = aclmdlCreateDataset();
+  // check inputs
+  if (input_index >= input_infos_.size()) {
+    MS_LOG(ERROR) << "inputs count not match, required count " << input_infos_.size() << ", given index "
+                  << input_index;
+    return INVALID_INPUTS;
+  }
+  if (dvpp_outputs_buffer_dev == nullptr) {
+    MS_LOG(ERROR) << "input " << 0 << " cannot be null";
+    return FAILED;
+  }
+  if (dvpp_outputs_buffer_size != input_infos_[input_index].buffer_size) {
+    MS_LOG(ERROR) << "input " << 0 << " data size not match, required size " << input_infos_[input_index].buffer_size
+                  << ", given count " << dvpp_outputs_buffer_size;
+    return INVALID_INPUTS;
+  }
+  // copy inputs
+  auto &info = input_infos_[input_index];
+  auto data_buffer = aclCreateDataBuffer(const_cast<void *>(dvpp_outputs_buffer_dev), info.buffer_size);
+  if (data_buffer == nullptr) {
+    MS_LOG(ERROR) << "Create Data Buffer failed";
+    return FAILED;
+  }
+  ret = aclmdlAddDatasetBuffer(inputs_, data_buffer);
+  if (ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "add data buffer failed";
+    aclDestroyDataBuffer(data_buffer);
+    return FAILED;
+  }
+  return SUCCESS;
+}
+
+Status ModelProcess::Predict(const std::map<std::string, Buffer> &inputs, std::map<std::string, Buffer> *outputs) {
+  MS_EXCEPTION_IF_NULL(outputs);
+  aclError acl_ret;
+  Status ret = CheckAndInitInput(inputs);
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "check or init input failed";
+    DestroyInputsDataset();
+    return ret;  // forward status error
+  }
+  acl_ret = aclmdlExecute(model_id_, inputs_, outputs_);
+  DestroyInputsDataset();
+  if (acl_ret != ACL_ERROR_NONE) {
+    MS_LOG(ERROR) << "Execute Model Failed";
+    return FAILED;
+  }
+  ret = BuildOutputs(outputs);
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "Build outputs faield";
+    return FAILED;
+  }
+  MS_LOG(INFO) << "excute model success";
+  return SUCCESS;
+}
+
+size_t ModelProcess::GetBatchSize() const {
+  if (input_infos_.empty()) {
+    MS_LOG(ERROR) << "Model is not loaded";
+    return 0;
+  }
+  if (input_infos_[0].dims.empty()) {
+    return 1;
+  }
+  return static_cast<size_t>(input_infos_[0].dims[0]);
+}
+
+Status ModelProcess::BuildOutputs(std::map<std::string, Buffer> *outputs) {
+  MS_EXCEPTION_IF_NULL(outputs);
+  aclError ret;
+  // copy outputs
+  outputs->clear();
+  aclrtMemcpyKind kind = is_run_on_device_ ? ACL_MEMCPY_HOST_TO_HOST : ACL_MEMCPY_DEVICE_TO_HOST;
+  for (size_t i = 0; i < output_infos_.size(); ++i) {
+    const auto &info = output_infos_[i];
+    // todo
+    outputs->emplace(info.name, Buffer());
+    auto output = outputs->rbegin()->second;
+    if (!output.ResizeData(info.buffer_size)) {
+      MS_LOG(ERROR) << "new output data buffer failed, data size " << info.buffer_size;
+      return FAILED;
+    }
+    ret = aclrtMemcpy(output.MutableData(), output.DataSize(), info.device_data, info.buffer_size, kind);
+    if (ret != ACL_ERROR_NONE) {
+      MS_LOG(ERROR) << "Memcpy output " << i << " from " << (is_run_on_device_ ? "host" : "device")
+                    << " to host failed, memory size " << info.buffer_size;
+      return FAILED;
+    }
+  }
+  return SUCCESS;
+}
+
+Status ModelProcess::GetInputsInfo(std::vector<Tensor> *tensor_list) const {
+  ConstructTensorDesc(input_infos_, tensor_list);
+  return SUCCESS;
+}
+
+Status ModelProcess::GetOutputsInfo(std::vector<Tensor> *tensor_list) const {
+  ConstructTensorDesc(output_infos_, tensor_list);
+  return SUCCESS;
+}
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/model/acl/model_process.h

@@ -0,0 +1,93 @@
+/**
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_MODEL_PROCESS_H
+#define MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_MODEL_PROCESS_H
+#include <vector>
+#include <string>
+#include <map>
+#include "acl/acl.h"
+#include "acl/acl_mdl.h"
+#include "acl/acl_rt.h"
+#include "include/api/status.h"
+#include "include/api/types.h"
+
+namespace mindspore::api {
+struct AclTensorInfo {
+  void *device_data;
+  size_t buffer_size;
+  aclDataType data_type;
+  std::vector<int64_t> dims;
+  std::string name;
+};
+
+struct ImagesDvppOutput {
+  void *buffer_device = nullptr;
+  size_t buffer_size = 0;
+  size_t input_index = 0;
+};
+
+class ModelProcess {
+ public:
+  ModelProcess()
+      : model_id_(0xffffffff),
+        is_run_on_device_(false),
+        model_desc_(nullptr),
+        inputs_(nullptr),
+        outputs_(nullptr),
+        input_infos_(),
+        output_infos_() {}
+  ~ModelProcess() {}
+  Status LoadModelFromFile(const std::string &file_name, uint32_t *model_id);
+  Status UnLoad();
+  Status Predict(const std::map<std::string, Buffer> &inputs, std::map<std::string, Buffer> *outputs);
+  Status PreInitModelResource();
+  Status GetInputsInfo(std::vector<Tensor> *tensor_list) const;
+  Status GetOutputsInfo(std::vector<Tensor> *tensor_list) const;
+
+  // override this method to avoid request/reply data copy
+  void SetIsDevice(bool is_device) { is_run_on_device_ = is_device; }
+
+  size_t GetBatchSize() const;
+  void set_model_id(uint32_t model_id) { model_id_ = model_id; }
+  uint32_t model_id() const { return model_id_; }
+
+ private:
+  Status CreateDataBuffer(void **data_mem_buffer, size_t buffer_size, aclmdlDataset *dataset);
+  Status CheckAndInitInput(const std::map<std::string, Buffer> &inputs);
+  Status CheckAndInitDvppInput(const void *dvpp_outputs_buffer_dev, size_t dvpp_outputs_buffer_size,
+                               size_t input_index);
+  Status BuildOutputs(std::map<std::string, Buffer> *outputs);
+  Status InitInputsBuffer();
+  Status InitOutputsBuffer();
+
+  void DestroyInputsDataset();
+  void DestroyInputsDataMem();
+  void DestroyInputsBuffer();
+  void DestroyOutputsBuffer();
+
+  uint32_t model_id_;
+  // if run one device(AICPU), there is no need to alloc device memory and copy inputs to(/outputs from) device
+  bool is_run_on_device_;
+  aclmdlDesc *model_desc_;
+  aclmdlDataset *inputs_;
+  aclmdlDataset *outputs_;
+  std::vector<AclTensorInfo> input_infos_;
+  std::vector<AclTensorInfo> output_infos_;
+};
+}  // namespace mindspore::api
+
+#endif  // MINDSPORE_CCSRC_CXXAPI_SESSION_ACL_MODEL_PROCESS_H

mindspore/ccsrc/cxx_api/model/model.cc

@@ -0,0 +1,98 @@
+/**
+ * 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 "include/api/model.h"
+#include "cxx_api/model/model_impl.h"
+#include "utils/utils.h"
+
+namespace mindspore::api {
+Status Model::LoadModel(const Buffer &model_data, ModelType type, const std::map<std::string, std::string> &options) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->LoadModel(model_data, type, options);
+}
+
+Status Model::LoadModel(const std::string &file_name, ModelType type,
+                        const std::map<std::string, std::string> &options) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->LoadModel(file_name, type, options);
+}
+
+Status Model::UnloadModel() {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->UnloadModel();
+}
+
+Status Model::Train(const DataSet &dataset, std::map<std::string, Buffer> *outputs) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->Train(dataset, outputs);
+}
+
+Status Model::Eval(const DataSet &dataset, std::map<std::string, Buffer> *outputs) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->Eval(dataset, outputs);
+}
+
+Status Model::Predict(const std::map<std::string, Buffer> &inputs, std::map<std::string, Buffer> *outputs) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->Predict(inputs, outputs);
+}
+
+Status Model::Predict(const std::vector<Buffer> &inputs, std::map<std::string, Buffer> *outputs) {
+  std::vector<Tensor> tensor_list;
+  auto ret = GetInputsInfo(&tensor_list);
+  if (ret != SUCCESS) {
+    MS_LOG(ERROR) << "GetInputsInfo failed.";
+    return ret;
+  }
+
+  if (inputs.size() != tensor_list.size()) {
+    MS_LOG(ERROR) << "Model need " << tensor_list.size() << " inputs, but given " << inputs.size();
+    return FAILED;
+  }
+
+  std::map<std::string, Buffer> inputs_with_map;
+  for (size_t i = 0; i < tensor_list.size(); ++i) {
+    inputs_with_map.emplace(tensor_list[i].Name(), inputs[i]);
+  }
+
+  return Predict(inputs_with_map, outputs);
+}
+
+Status Model::GetInputsInfo(std::vector<Tensor> *tensor_list) const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->GetInputsInfo(tensor_list);
+}
+
+Status Model::GetOutputsInfo(std::vector<Tensor> *tensor_list) const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->GetOutputsInfo(tensor_list);
+}
+
+Model::Model(const std::string &device_type, uint32_t device_id)
+    : impl_(ModelFactory::Instance().Create(device_type, device_id)) {
+  if (impl_ == nullptr) {
+    MS_LOG(EXCEPTION) << "Create session type " << device_type << " failed";
+  }
+}
+
+Model::Model(NetWork network, const std::string &device_type, uint32_t device_id) {
+  // todo
+  if (impl_ == nullptr) {
+    MS_LOG(EXCEPTION) << "Create session type " << device_type << " failed";
+  }
+}
+
+Model::~Model() {}
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/model/model_impl.h

@@ -0,0 +1,93 @@
+/**
+ * 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.
+ */
+#ifndef MINDSPORE_CCSRC_CXX_API_MODEL_MODEL_IMPL_H
+#define MINDSPORE_CCSRC_CXX_API_MODEL_MODEL_IMPL_H
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+#include "include/api/model.h"
+#include "utils/utils.h"
+
+namespace mindspore::api {
+class ModelImpl {
+ public:
+  ModelImpl() = default;
+  virtual ~ModelImpl() = default;
+
+  virtual Status LoadModel(const Buffer &model_data, ModelType type,
+                           const std::map<std::string, std::string> &options) = 0;
+  virtual Status LoadModel(const std::string &file_name, ModelType type,
+                           const std::map<std::string, std::string> &options) = 0;
+  virtual Status UnloadModel() = 0;
+
+  virtual Status Train(const DataSet &dataset, std::map<std::string, Buffer> *outputs) = 0;
+  virtual Status Eval(const DataSet &dataset, std::map<std::string, Buffer> *outputs) = 0;
+  virtual Status Predict(const std::map<std::string, Buffer> &inputs, std::map<std::string, Buffer> *outputs) = 0;
+
+  virtual Status GetInputsInfo(std::vector<Tensor> *tensor_list) const = 0;
+  virtual Status GetOutputsInfo(std::vector<Tensor> *tensor_list) const = 0;
+};
+
+using ModelCreator = std::function<std::shared_ptr<ModelImpl>(uint32_t device_id)>;
+class ModelFactory {
+ public:
+  ModelFactory(const ModelFactory &) = delete;
+  void operator=(const ModelFactory &) = delete;
+
+  static ModelFactory &Instance() {
+    static ModelFactory instance;
+    return instance;
+  }
+
+  void Register(const std::string &device_name, ModelCreator &&model_creator) {
+    if (model_creators_.find(device_name) == model_creators_.end()) {
+      (void)model_creators_.emplace(device_name, model_creator);
+    }
+  }
+
+  std::shared_ptr<ModelImpl> Create(const std::string &device_name, uint32_t device_id) {
+    auto iter = model_creators_.find(device_name);
+    if (model_creators_.end() != iter) {
+      MS_EXCEPTION_IF_NULL(iter->second);
+      return (iter->second)(device_id);
+    }
+    return nullptr;
+  }
+
+ private:
+  ModelFactory() = default;
+  ~ModelFactory() = default;
+  std::map<std::string, ModelCreator> model_creators_;
+};
+
+class ModelRegistrar {
+ public:
+  ModelRegistrar(const std::string &device_name, ModelCreator model_creator) {
+    ModelFactory::Instance().Register(device_name, std::move(model_creator));
+  }
+  ~ModelRegistrar() = default;
+};
+
+#define API_REG_MODEL(DEVICE_NAME, MODEL_CLASS)                              \
+  static const ModelRegistrar g_api_model_registrar__##DEVICE_NAME##_##_reg( \
+    #DEVICE_NAME, [](uint32_t device_id) { return std::make_shared<MODEL_CLASS>(device_id); });
+
+}  // namespace mindspore::api
+
+#endif  // MINDSPORE_CCSRC_CXX_API_MODEL_MODEL_IMPL_H

mindspore/ccsrc/cxx_api/ops/ops.cc

@@ -0,0 +1,38 @@
+/**
+ * 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 "include/api/ops/ops.h"
+
+namespace mindspore::api {
+Conv2D::Conv2D(int out_channel, const std::vector<int> &kernel_size, int mode, const std::string &pad_mode,
+               const std::vector<int> &pad, const std::vector<int> &stride, const std::vector<int> &dilation, int group)
+    : OpCell("Conv2D"),
+      out_channel(out_channel),
+      kernel_size(kernel_size),
+      mode(mode),
+      pad_mode(pad_mode),
+      pad(pad),
+      stride(stride),
+      dilation(dilation),
+      group(group) {}
+
+Output Conv2D::operator()(const Input &input1, const Input &input2) const {
+  return CellBase::operator()({input1, input2})[0];
+}
+
+std::vector<Output> Conv2D::Construct(const std::vector<Input> &inputs) {
+  return {Output(shared_from_this(), inputs, 1)};
+}
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/serialization.cc

@@ -0,0 +1,39 @@
+/**
+ * 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 "include/api/serialization.h"
+#include "utils/log_adapter.h"
+
+namespace mindspore::api {
+Status Serialization::LoadCheckPoint(const std::string &ckpt_file, std::map<std::string, Buffer> *parameters) {
+  MS_LOG(ERROR) << "Unsupported feature.";
+  return FAILED;
+}
+
+Status Serialization::SetParameters(const std::map<std::string, Buffer> &parameters, Model *model) {
+  MS_LOG(ERROR) << "Unsupported feature.";
+  return FAILED;
+}
+
+Status Serialization::ExportModel(const Model &model, ModelType model_type, Buffer *model_data) {
+  MS_LOG(ERROR) << "Unsupported feature.";
+  return FAILED;
+}
+
+Status Serialization::ExportModel(const Model &model, ModelType model_type, const std::string &model_file) {
+  MS_LOG(ERROR) << "Unsupported feature.";
+  return FAILED;
+}
+}  // namespace mindspore::api

mindspore/ccsrc/cxx_api/types.cc

@@ -0,0 +1,226 @@
+/**
+ * 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 "include/api/types.h"
+#include <numeric>
+#include "securec/include/securec.h"
+#include "utils/utils.h"
+
+namespace mindspore::api {
+class DataImpl {
+ public:
+  DataImpl() : data_() {}
+  ~DataImpl() = default;
+  DataImpl(const void *data, size_t data_len) { SetData(data, data_len); }
+
+  const void *Data() const { return data_.data(); }
+  void *MutableData() { return data_.data(); }
+  size_t DataSize() const { return data_.size(); }
+
+  bool ResizeData(size_t data_len) {
+    data_.resize(data_len);
+    return true;
+  }
+
+  bool SetData(const void *data, size_t data_len) {
+    ResizeData(data_len);
+    if (DataSize() != data_len) {
+      MS_LOG(ERROR) << "Set data failed, tensor current data size " << DataSize() << " not match data len " << data_len;
+      return false;
+    }
+
+    if (data == nullptr) {
+      return data_len == 0;
+    }
+
+    if (MutableData() == nullptr) {
+      MS_LOG(ERROR) << "Set data failed, data len " << data_len;
+      return false;
+    }
+
+    auto ret = memcpy_s(MutableData(), DataSize(), data, data_len);
+    if (ret != 0) {
+      MS_LOG(ERROR) << "Set data memcpy_s failed, ret = " << ret;
+      return false;
+    }
+    return true;
+  }
+
+ protected:
+  std::vector<uint8_t> data_;
+};
+
+class Buffer::Impl : public DataImpl {
+ public:
+  Impl() : DataImpl() {}
+  ~Impl() = default;
+  Impl(const void *data, size_t data_len) : DataImpl(data, data_len) {}
+};
+
+class Tensor::Impl : public DataImpl {
+ public:
+  Impl() : DataImpl(), name_(), type_(DataType::kMsUnknown), shape_() {}
+  ~Impl() = default;
+  Impl(const std::string &name, api::DataType type, const std::vector<int64_t> &shape, const void *data,
+       size_t data_len)
+      : DataImpl(data, data_len), name_(name), type_(type), shape_(shape) {}
+
+  const std::string &Name() const { return name_; }
+  void SetName(const std::string &name) { name_ = name; }
+
+  api::DataType DataType() const { return type_; }
+  void SetDataType(api::DataType type) { type_ = type; }
+
+  void SetShape(const std::vector<int64_t> &shape) { shape_ = shape; }
+  const std::vector<int64_t> &Shape() const { return shape_; }
+
+  int64_t ElementNum() const {
+    std::vector<int64_t> shapex = Shape();
+    return std::accumulate(shapex.begin(), shapex.end(), 1LL, std::multiplies<int64_t>());
+  }
+
+  static int GetTypeSize(api::DataType type) {
+    static const std::map<api::DataType, size_t> type_size_map = {
+      {kMsBool, sizeof(bool)},       {kMsFloat64, sizeof(double)},   {kMsInt8, sizeof(int8_t)},
+      {kMsUint8, sizeof(uint8_t)},   {kMsInt16, sizeof(int16_t)},    {kMsUint16, sizeof(uint16_t)},
+      {kMsInt32, sizeof(int32_t)},   {kMsUint32, sizeof(uint32_t)},  {kMsInt64, sizeof(int64_t)},
+      {kMsUint64, sizeof(uint64_t)}, {kMsFloat16, sizeof(uint16_t)}, {kMsFloat32, sizeof(float)},
+    };
+    auto it = type_size_map.find(type);
+    if (it != type_size_map.end()) {
+      return it->second;
+    }
+
+    MS_LOG(WARNING) << "Cannot find data type " << type;
+    return 0;
+  }
+
+ private:
+  std::string name_;
+  api::DataType type_;
+  std::vector<int64_t> shape_;
+};
+
+Tensor::Tensor() : impl_(std::make_shared<Impl>()) {}
+Tensor::Tensor(const std::string &name, api::DataType type, const std::vector<int64_t> &shape, const void *data,
+               size_t data_len)
+    : impl_(std::make_shared<Impl>(name, type, shape, data, data_len)) {}
+Tensor::~Tensor() = default;
+
+Tensor Tensor::Clone() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  Tensor ret;
+  ret.impl_ = std::make_shared<Impl>(*impl_);
+  return ret;
+}
+
+const std::string &Tensor::Name() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->Name();
+}
+
+void Tensor::SetName(const std::string &name) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  impl_->SetName(name);
+}
+
+DataType Tensor::DataType() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->DataType();
+}
+
+void Tensor::SetDataType(api::DataType type) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  impl_->SetDataType(type);
+}
+
+const std::vector<int64_t> &Tensor::Shape() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->Shape();
+}
+
+void Tensor::SetShape(const std::vector<int64_t> &shape) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  impl_->SetShape(shape);
+}
+
+const void *Tensor::Data() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->Data();
+}
+
+void *Tensor::MutableData() {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->MutableData();
+}
+
+size_t Tensor::DataSize() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->DataSize();
+}
+
+bool Tensor::ResizeData(size_t data_len) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->ResizeData(data_len);
+}
+
+bool Tensor::SetData(const void *data, size_t data_len) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->SetData(data, data_len);
+}
+
+int64_t Tensor::ElementNum() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->ElementNum();
+}
+
+int Tensor::GetTypeSize(api::DataType type) { return Impl::GetTypeSize(type); }
+
+Buffer::Buffer() : impl_(std::make_shared<Impl>()) {}
+Buffer::Buffer(const void *data, size_t data_len) : impl_(std::make_shared<Impl>(data, data_len)) {}
+Buffer::~Buffer() = default;
+
+Buffer Buffer::Clone() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  Buffer ret;
+  ret.impl_ = std::make_shared<Impl>(*impl_);
+  return ret;
+}
+
+const void *Buffer::Data() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->Data();
+}
+
+void *Buffer::MutableData() {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->MutableData();
+}
+
+size_t Buffer::DataSize() const {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->DataSize();
+}
+
+bool Buffer::ResizeData(size_t data_len) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->ResizeData(data_len);
+}
+
+bool Buffer::SetData(const void *data, size_t data_len) {
+  MS_EXCEPTION_IF_NULL(impl_);
+  return impl_->SetData(data, data_len);
+}
+}  // namespace mindspore::api

mindspore/ccsrc/transform/graph_ir/CMakeLists.txt

@@ -1,5 +1,6 @@
-if (ENABLE_GE OR ENABLE_D)
+if (ENABLE_GE OR ENABLE_D OR ENABLE_ACL)
     file(GLOB_RECURSE _TRANSFORM_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.cc")
+    list(REMOVE_ITEM _TRANSFORM_SRC_LIST "graph_ir/op_declare/hcom_ops_declare.cc")
     set_property(SOURCE ${_TRANSFORM_SRC_LIST} PROPERTY COMPILE_DEFINITIONS SUBMODULE_ID=mindspore::SubModuleId::SM_GE_ADPT)
     add_library(_mindspore_transform_graph_ir_obj OBJECT ${_TRANSFORM_SRC_LIST})
 

mindspore/ccsrc/transform/graph_ir/convert.cc

@@ -1579,7 +1579,6 @@ OperatorPtr DfGraphConvertor::ConvertParameter(const AnfNodePtr node) {
   // build index for parameter using name
   std::string name = std::static_pointer_cast<Parameter>(node)->name();
   params_[name] = node;
-
   std::ostringstream ss;
   ss << "op" << node.get();
   op_draw_name_[node.get()] = ss.str();

serving/CMakeLists.txt

@@ -76,8 +76,6 @@ file(GLOB_RECURSE CORE_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
 
 list(APPEND SERVING_SRC "main.cc" ${hw_proto_srcs} ${hw_grpc_srcs} ${CORE_SRC_LIST})
 
-option(ENABLE_ACL "enable acl" OFF)
-
 if (ENABLE_ACL)
     if (DEFINED ENV{ASCEND_CUSTOM_PATH})
         set(ASCEND_PATH $ENV{ASCEND_CUSTOM_PATH})
@@ -85,9 +83,11 @@ if (ENABLE_ACL)
         set(ASCEND_PATH /usr/local/Ascend)
     endif ()
     set(ACL_LIB_DIR ${ASCEND_PATH}/acllib/)
-    MESSAGE("acl lib dir " ${ACL_LIB_DIR})
+    set(ATLAS_ACL_LIB_DIR ${ASCEND_PATH}/ascend-toolkit/latest/acllib)
+    MESSAGE("hisi acl lib dir " ${ACL_LIB_DIR} " ,atlas acl lib dir " ${ATLAS_ACL_LIB_DIR})
 
     include_directories(${ACL_LIB_DIR}/include/)
+    include_directories(${ATLAS_ACL_LIB_DIR}/include/)
     file(GLOB_RECURSE ACL_SESSION_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "acl/*.cc")
     list(APPEND SERVING_SRC ${ACL_SESSION_SRC_LIST})
 endif ()
@@ -112,10 +112,13 @@ endif ()
 if (ENABLE_ACL)
     add_compile_definitions(ENABLE_ACL)
     add_compile_definitions(ENABLE_DVPP_INTERFACE)
-    set(ALC_LIB_SO ${ACL_LIB_DIR}/lib64/libruntime.so ${ACL_LIB_DIR}/lib64/libascendcl.so
-            ${ACL_LIB_DIR}/lib64/libacl_retr.so ${ACL_LIB_DIR}/lib64/libacl_cblas.so
-            ${ACL_LIB_DIR}/lib64/libacl_dvpp.so)
-    target_link_libraries(ms_serving ${ALC_LIB_SO})
+    find_library(acl libascendcl.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_retr libacl_retr.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_cblas libacl_cblas.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_dvpp libacl_dvpp.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+    find_library(acl_runtime libruntime.so ${ACL_LIB_DIR}/lib64 ${ATLAS_ACL_LIB_DIR}/lib64)
+
+    target_link_libraries(ms_serving ${acl} ${acl_retr} ${acl_cblas} ${acl_dvpp} ${acl_runtime})
     target_link_libraries(ms_serving jpeg_turbo::jpeg securec)
 else ()
     target_link_libraries(ms_serving inference mindspore_gvar)

setup.py

@@ -130,7 +130,11 @@ package_data = {
         'lib/*.so*',
         'lib/*.a',
         '.commit_id',
-        'ms_serving'
+        'ms_serving',
+        'include/*',
+        'include/*/*',
+        'include/*/*/*',
+        'include/*/*/*/*'
     ]
 }
 

tests/ut/cpp/CMakeLists.txt

@@ -56,6 +56,7 @@ if(ENABLE_MINDDATA)
             ./utils/*.cc
             ./vm/*.cc
             ./ps/*.cc
+            ./cxx_api/*.cc
             )
    
     if(NOT ENABLE_PYTHON)
@@ -176,7 +177,7 @@ if (USE_GLOG)
     target_link_libraries(ut_tests PRIVATE mindspore::glog)
 endif()
 
-target_link_libraries(ut_tests PRIVATE mindspore securec graph)
+target_link_libraries(ut_tests PRIVATE mindspore mindspore_shared_lib securec graph)
 
 # link grpc
 if (EXISTS ${grpc_ROOT}/lib64)

tests/ut/cpp/cxx_api/types_test.cc

@@ -0,0 +1,169 @@
+/**
+ * Copyright 2019 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 <memory>
+#include "common/common_test.h"
+#include "include/api/types.h"
+
+namespace mindspore {
+class TestCxxApiTypes : public UT::Common {
+ public:
+  TestCxxApiTypes() = default;
+};
+
+TEST_F(TestCxxApiTypes, test_tensor_set_name_SUCCESS) {
+  std::string tensor_name_before = "TEST1";
+  std::string tensor_name_after = "TEST2";
+  api::Tensor tensor1(tensor_name_before, api::DataType::kMsFloat32, {}, nullptr, 0);
+  api::Tensor tensor2 = tensor1;
+  api::Tensor tensor3 = tensor1.Clone();
+
+  // name
+  ASSERT_EQ(tensor1.Name(), tensor_name_before);
+  ASSERT_EQ(tensor2.Name(), tensor_name_before);
+  ASSERT_EQ(tensor3.Name(), tensor_name_before);
+
+  tensor1.SetName(tensor_name_after);
+  ASSERT_EQ(tensor1.Name(), tensor_name_after);
+  ASSERT_EQ(tensor2.Name(), tensor_name_after);
+  ASSERT_EQ(tensor3.Name(), tensor_name_before);
+}
+
+TEST_F(TestCxxApiTypes, test_tensor_set_dtype_SUCCESS) {
+  api::Tensor tensor1("", api::DataType::kMsFloat32, {}, nullptr, 0);
+  api::Tensor tensor2 = tensor1;
+  api::Tensor tensor3 = tensor1.Clone();
+
+  // dtype
+  ASSERT_EQ(tensor1.DataType(), api::DataType::kMsFloat32);
+  ASSERT_EQ(tensor2.DataType(), api::DataType::kMsFloat32);
+  ASSERT_EQ(tensor3.DataType(), api::DataType::kMsFloat32);
+
+  tensor1.SetDataType(api::DataType::kMsUint32);
+  ASSERT_EQ(tensor1.DataType(), api::DataType::kMsUint32);
+  ASSERT_EQ(tensor2.DataType(), api::DataType::kMsUint32);
+  ASSERT_EQ(tensor3.DataType(), api::DataType::kMsFloat32);
+}
+
+TEST_F(TestCxxApiTypes, test_tensor_set_shape_SUCCESS) {
+  std::vector<int64_t> shape = {3, 4, 5, 6};
+  api::Tensor tensor1("", api::DataType::kMsFloat32, {}, nullptr, 0);
+  api::Tensor tensor2 = tensor1;
+  api::Tensor tensor3 = tensor1.Clone();
+
+  // shape
+  ASSERT_EQ(tensor1.Shape(), std::vector<int64_t>());
+  ASSERT_EQ(tensor2.Shape(), std::vector<int64_t>());
+  ASSERT_EQ(tensor3.Shape(), std::vector<int64_t>());
+
+  tensor1.SetShape(shape);
+  ASSERT_EQ(tensor1.Shape(), shape);
+  ASSERT_EQ(tensor2.Shape(), shape);
+  ASSERT_EQ(tensor3.Shape(), std::vector<int64_t>());
+}
+
+
+TEST_F(TestCxxApiTypes, test_tensor_util_SUCCESS) {
+  std::vector<int64_t> shape = {3, 4, 5, 6};
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Tensor tensor1("", api::DataType::kMsFloat32, shape, data.data(), data.size() * sizeof(uint32_t));
+
+  // data
+  ASSERT_EQ(api::Tensor::GetTypeSize(api::DataType::kMsUint32), sizeof(uint32_t));
+  ASSERT_EQ(tensor1.ElementNum(), 3 * 4 * 5 * 6);
+}
+
+TEST_F(TestCxxApiTypes, test_tensor_data_ref_and_copy_SUCCESS) {
+  std::vector<int64_t> shape = {3, 4, 5, 6};
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Tensor tensor1("", api::DataType::kMsFloat32, shape, data.data(), data.size() * sizeof(uint32_t));
+  api::Tensor tensor2 = tensor1;
+  api::Tensor tensor3 = tensor1.Clone();
+
+  // data
+  ASSERT_EQ(tensor1.DataSize(), tensor2.DataSize());
+  ASSERT_EQ(tensor1.DataSize(), tensor3.DataSize());
+  ASSERT_EQ(tensor1.Data(), tensor2.MutableData());
+  ASSERT_NE(tensor1.Data(), tensor3.Data());
+}
+
+TEST_F(TestCxxApiTypes, test_tensor_resize_data_SUCCESS) {
+  std::vector<int64_t> shape = {3, 4, 5, 6};
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Tensor tensor1("", api::DataType::kMsFloat32, shape, data.data(), data.size() * sizeof(uint32_t));
+
+  // data
+  ASSERT_EQ(tensor1.ResizeData(0), true);
+}
+
+TEST_F(TestCxxApiTypes, test_tensor_set_data_wrong_data_size_FAILED) {
+  std::vector<int64_t> shape = {3, 4, 5, 6};
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Tensor tensor1("", api::DataType::kMsFloat32, shape, data.data(), data.size() * sizeof(uint32_t));
+
+  // data
+  ASSERT_EQ(tensor1.SetData(nullptr, 1), false);
+  ASSERT_EQ(tensor1.SetData(data.data(), 0), false);
+}
+
+TEST_F(TestCxxApiTypes, test_tensor_set_data_SUCCESS) {
+  std::vector<int64_t> shape = {3, 4, 5, 6};
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Tensor tensor1("", api::DataType::kMsFloat32, shape, data.data(), data.size() * sizeof(uint32_t));
+
+  // data
+  ASSERT_EQ(tensor1.SetData(nullptr, 0), true);
+  ASSERT_EQ(tensor1.SetData(data.data(), data.size() * sizeof(uint32_t)), true);
+}
+
+TEST_F(TestCxxApiTypes, test_buffer_data_ref_and_copy_SUCCESS) {
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Buffer buffer1(data.data(), data.size() * sizeof(uint32_t));
+  api::Buffer buffer2 = buffer1;
+  api::Buffer buffer3 = buffer1.Clone();
+
+  // data
+  ASSERT_EQ(buffer1.DataSize(), buffer2.DataSize());
+  ASSERT_EQ(buffer1.DataSize(), buffer3.DataSize());
+  ASSERT_EQ(buffer1.Data(), buffer2.MutableData());
+  ASSERT_NE(buffer1.Data(), buffer3.Data());
+}
+
+TEST_F(TestCxxApiTypes, test_buffer_resize_data_SUCCESS) {
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Buffer buffer1(data.data(), data.size() * sizeof(uint32_t));
+
+  // data
+  ASSERT_EQ(buffer1.ResizeData(0), true);
+}
+
+TEST_F(TestCxxApiTypes, test_buffer_set_data_wrong_data_size_FAILED) {
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Buffer buffer1(data.data(), data.size() * sizeof(uint32_t));
+
+  // data
+  ASSERT_EQ(buffer1.SetData(nullptr, 1), false);
+  ASSERT_EQ(buffer1.SetData(data.data(), 0), false);
+}
+
+TEST_F(TestCxxApiTypes, test_buffer_set_data_SUCCESS) {
+  std::vector<uint32_t> data(3 * 4 * 5 * 6, 123);
+  api::Buffer buffer1(data.data(), data.size() * sizeof(uint32_t));
+
+  // data
+  ASSERT_EQ(buffer1.SetData(nullptr, 0), true);
+  ASSERT_EQ(buffer1.SetData(data.data(), data.size() * sizeof(uint32_t)), true);
+}
+}  // namespace mindspore