mindspore 2.4.0__cp311-cp311-macosx_11_0_arm64.whl

mindspore/include/api/model_parallel_runner.h

@@ -0,0 +1,168 @@
+/**
+ * Copyright 2022-2023 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_PARALLEL_RUNNER_H
+#define MINDSPORE_INCLUDE_API_MODEL_PARALLEL_RUNNER_H
+#include <vector>
+#include <memory>
+#include <utility>
+#include <map>
+#include <string>
+#include "include/api/status.h"
+#include "include/api/context.h"
+namespace mindspore {
+/// \brief The RunnerConfig class  is used to store environment variables during execution
+/// management.
+class MS_API RunnerConfig {
+ public:
+  struct Data;
+  RunnerConfig();
+  ~RunnerConfig();
+
+  /// \brief Set the number of workers at runtime. Only valid for ModelParallelRunner.
+  ///
+  /// \param[in] workers_num the number of workers at runtime.
+  void SetWorkersNum(int32_t workers_num);
+
+  /// \brief Get the current operators parallel workers number setting. Only valid for ModelParallelRunner.
+  ///
+  /// \return The current operators parallel workers number setting.
+  int32_t GetWorkersNum() const;
+
+  /// \brief Set the context at runtime. Only valid for ModelParallelRunner.
+  ///
+  /// \param[in] context store environment variables at runtime.
+  void SetContext(const std::shared_ptr<Context> &context);
+
+  /// \brief Get the current context setting. Only valid for ModelParallelRunner.
+  ///
+  /// \return The current operators context setting.
+  std::shared_ptr<Context> GetContext() const;
+
+  /// \brief Set the config before runtime. Only valid for ModelParallelRunner.
+  ///
+  /// \param[in] section The category of the configuration parameter.
+  /// \param[in] config store environment variables before runtime.
+  inline void SetConfigInfo(const std::string &section, const std::map<std::string, std::string> &config);
+
+  /// \brief Get the current config setting. Only valid for ModelParallelRunner.
+  ///
+  /// \return The current config setting.
+  inline std::map<std::string, std::map<std::string, std::string>> GetConfigInfo() const;
+
+  /// \brief Set the config path before runtime. Only valid for ModelParallelRunner.
+  ///
+  /// \param[in] config_path The path of the configuration parameter.
+  inline void SetConfigPath(const std::string &config_path);
+
+  /// \brief Get the current config path. Only valid for ModelParallelRunner.
+  ///
+  /// \return The current config path.
+  inline std::string GetConfigPath() const;
+
+  /// \brief Set the device id list at runtime, make the model run on different npu/gpu devices. Only valid for
+  /// ModelParallelRunner.
+  ///
+  /// \param[in] device_ids The device id list at runtime.
+  void SetDeviceIds(const std::vector<uint32_t> &device_ids);
+
+  /// \brief Get the device id list at runtime. Only valid for ModelParallelRunner.
+  ///
+  /// \return The device id list.
+  std::vector<uint32_t> GetDeviceIds() const;
+
+ private:
+  void SetConfigInfo(const std::vector<char> &section, const std::map<std::vector<char>, std::vector<char>> &config);
+  std::map<std::vector<char>, std::map<std::vector<char>, std::vector<char>>> GetConfigInfoChar() const;
+  void SetConfigPath(const std::vector<char> &config_path);
+  std::vector<char> GetConfigPathChar() const;
+  std::shared_ptr<Data> data_ = nullptr;
+};
+
+void RunnerConfig::SetConfigInfo(const std::string &section, const std::map<std::string, std::string> &config) {
+  SetConfigInfo(StringToChar(section), MapStringToVectorChar(config));
+}
+
+std::map<std::string, std::map<std::string, std::string>> RunnerConfig::GetConfigInfo() const {
+  return MapMapCharToString(GetConfigInfoChar());
+}
+
+void RunnerConfig::SetConfigPath(const std::string &config_path) { SetConfigPath(StringToChar(config_path)); }
+
+std::string RunnerConfig::GetConfigPath() const { return CharToString(GetConfigPathChar()); }
+
+class ModelParallelRunnerImpl;
+
+/// \brief The ModelParallelRunner class is used to define a MindSpore ModelParallelRunner, facilitating Model
+/// management.
+class MS_API ModelParallelRunner {
+ public:
+  ModelParallelRunner();
+  ~ModelParallelRunner();
+
+  /// \brief build a model parallel runner from model path so that it can run on a device. Supports importing the `ms`
+  /// model (exported by the `converter_lite` tool) and the `mindir` model (exported by MindSpore or exported by the
+  /// `converter_lite` tool). The support for the `ms` model will be removed in future iterations, and it is recommended
+  /// to use the `mindir` model for inference. When using the `ms` model for inference, please keep the suffix name of
+  /// the model as `.ms`, otherwise it will not be recognized.
+  ///
+  /// \param[in] model_path Define the model path.
+  /// \param[in] runner_config Define the config used to store options during model pool init.
+  ///
+  /// \return Status.
+  inline Status Init(const std::string &model_path, const std::shared_ptr<RunnerConfig> &runner_config = nullptr);
+
+  /// \brief build a model parallel runner from model buffer so that it can run on a device. This interface only
+  /// supports passing in `mindir` model file data.
+  ///
+  /// \param[in] model_data Define the buffer read from a model file.
+  /// \param[in] data_size Define bytes number of model buffer.
+  /// \param[in] runner_config Define the config used to store options during model pool init.
+  ///
+  /// \return Status.
+  Status Init(const void *model_data, const size_t data_size,
+              const std::shared_ptr<RunnerConfig> &runner_config = nullptr);
+
+  /// \brief Obtains all input tensors information of the model.
+  ///
+  /// \return The vector that includes all input tensors.
+  std::vector<MSTensor> GetInputs();
+
+  /// \brief Obtains all output tensors information of the model.
+  ///
+  /// \return The vector that includes all output tensors.
+  std::vector<MSTensor> GetOutputs();
+
+  /// \brief Inference ModelParallelRunner.
+  ///
+  /// \param[in] inputs A vector where model inputs are arranged in sequence.
+  /// \param[out] outputs Which is a pointer to a vector. The model outputs are filled in the container in sequence.
+  /// \param[in] before CallBack before predict.
+  /// \param[in] after CallBack after predict.
+  ///
+  /// \return Status.
+  Status Predict(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs,
+                 const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr);
+
+ private:
+  Status Init(const std::vector<char> &model_path, const std::shared_ptr<RunnerConfig> &runner_config);
+  std::shared_ptr<ModelParallelRunnerImpl> model_parallel_runner_impl_ = nullptr;
+};
+
+Status ModelParallelRunner::Init(const std::string &model_path, const std::shared_ptr<RunnerConfig> &runner_config) {
+  return Init(StringToChar(model_path), runner_config);
+}
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_MODEL_PARALLEL_RUNNER_H

mindspore/include/api/serialization.h

@@ -0,0 +1,185 @@
+/**
+ * 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"
+#include "include/api/graph.h"
+#include "include/api/dual_abi_helper.h"
+
+namespace mindspore {
+/// \brief The Serialization class is used to summarize methods for reading and writing model files.
+class MS_API Serialization {
+ public:
+  /// \brief Loads a model file from memory buffer.
+  ///
+  /// \param[in] model_data A buffer filled by model file.
+  /// \param[in] data_size The size of the buffer.
+  /// \param[in] model_type The Type of model file, options are ModelType::kMindIR, ModelType::kOM.
+  /// \param[out] graph The output parameter, an object saves graph data.
+  /// \param[in] dec_key The decryption key, key length is 16, 24, or 32. Not supported on MindSpore Lite.
+  /// \param[in] dec_mode The decryption mode, optional options are AES-GCM, AES-CBC. Not supported on MindSpore Lite.
+  ///
+  /// \return Status.
+  inline static Status Load(const void *model_data, size_t data_size, ModelType model_type, Graph *graph,
+                            const Key &dec_key = {}, const std::string &dec_mode = kDecModeAesGcm);
+
+  /// \brief Loads a model file from path.
+  ///
+  /// \param[in] file The path of model file.
+  /// \param[in] model_type The Type of model file, options are ModelType::kMindIR, ModelType::kOM.
+  /// \param[out] graph The output parameter, an object saves graph data.
+  /// \param[in] dec_key The decryption key, key length is 16, 24, or 32. Not supported on MindSpore Lite.
+  /// \param[in] dec_mode The decryption mode, optional options are AES-GCM, AES-CBC. Not supported on MindSpore Lite.
+  ///
+  /// \return Status.
+  inline static Status Load(const std::string &file, ModelType model_type, Graph *graph, const Key &dec_key = {},
+                            const std::string &dec_mode = kDecModeAesGcm);
+
+  /// \brief Load multiple models from multiple files, MindSpore Lite does not provide this feature.
+  ///
+  /// \param[in] files The path of model files.
+  /// \param[in] model_type The Type of model file, options are ModelType::kMindIR, ModelType::kOM.
+  /// \param[out] graphs The output parameter, an object saves graph data.
+  /// \param[in] dec_key The decryption key, key length is 16, 24, or 32.
+  /// \param[in] dec_mode The decryption mode, optional options are AES-GCM, AES-CBC.
+  ///
+  /// \return Status.
+  inline static Status Load(const std::vector<std::string> &files, ModelType model_type, std::vector<Graph> *graphs,
+                            const Key &dec_key = {}, const std::string &dec_mode = kDecModeAesGcm);
+
+  /// \brief Configure model parameters, MindSpore Lite does not provide this feature.
+  ///
+  /// \param[in] parameters The parameters.
+  /// \param[in] model The model.
+  ///
+  /// \return Status.
+  inline static Status SetParameters(const std::map<std::string, Buffer> &parameters, Model *model);
+
+  /// \brief Export training model from memory buffer, MindSpore Lite does not provide this feature.
+  ///
+  /// \param[in] model The model data.
+  /// \param[in] model_type The model file type.
+  /// \param[out] model_data The model buffer.
+  /// \param[in] quantization_type The quantification type.
+  /// \param[in] export_inference_only Whether to export a reasoning only model.
+  /// \param[in] output_tensor_name The set the name of the output tensor of the exported reasoning model, default as
+  /// empty, and export the complete reasoning model.
+  ///
+  /// \return Status.
+  inline static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data,
+                                   QuantizationType quantization_type = kNoQuant, bool export_inference_only = true,
+                                   const std::vector<std::string> &output_tensor_name = {});
+
+  /// \brief Export training model from file.
+  ///
+  /// \param[in] model The model data.
+  /// \param[in] model_type The model file type.
+  /// \param[in] model_file The path of exported model file.
+  /// \param[in] quantization_type The quantification type.
+  /// \param[in] export_inference_only Whether to export a reasoning only model.
+  /// \param[in] output_tensor_name The set the name of the output tensor of the exported reasoning model, default as
+  /// empty, and export the complete reasoning model.
+  ///
+  /// \return Status.
+  inline static Status ExportModel(const Model &model, ModelType model_type, const std::string &model_file,
+                                   QuantizationType quantization_type = kNoQuant, bool export_inference_only = true,
+                                   std::vector<std::string> output_tensor_name = {});
+
+  /// \brief Experimental feature. Export model's weights, which can be used in micro only.
+  ///
+  /// \param[in] model The model data.
+  /// \param[in] model_type The model file type.
+  /// \param[in] weight_file The path of exported weight file.
+  /// \param[in] is_inference Whether to export weights from a reasoning model. Currently, only support this is `true`.
+  /// \param[in] enable_fp16 Float-weight is whether to be saved in float16 format.
+  /// \param[in] changeable_weights_name The set the name of these weight tensors, whose shape is changeable.
+  ///
+  /// \return Status.
+  inline static Status ExportWeightsCollaborateWithMicro(const Model &model, ModelType model_type,
+                                                         const std::string &weight_file, bool is_inference = true,
+                                                         bool enable_fp16 = false,
+                                                         const std::vector<std::string> &changeable_weights_name = {});
+
+ private:
+  static Status Load(const void *model_data, size_t data_size, ModelType model_type, Graph *graph, const Key &dec_key,
+                     const std::vector<char> &dec_mode);
+  static Status Load(const std::vector<char> &file, ModelType model_type, Graph *graph);
+  static Status Load(const std::vector<char> &file, ModelType model_type, Graph *graph, const Key &dec_key,
+                     const std::vector<char> &dec_mode);
+  static Status Load(const std::vector<std::vector<char>> &files, ModelType model_type, std::vector<Graph> *graphs,
+                     const Key &dec_key, const std::vector<char> &dec_mode);
+  static Status SetParameters(const std::map<std::vector<char>, Buffer> &parameters, Model *model);
+  static Status ExportModel(const Model &model, ModelType model_type, const std::vector<char> &model_file,
+                            QuantizationType quantization_type, bool export_inference_only,
+                            const std::vector<std::vector<char>> &output_tensor_name);
+  static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data,
+                            QuantizationType quantization_type, bool export_inference_only,
+                            const std::vector<std::vector<char>> &output_tensor_name);
+  static Status ExportWeightsCollaborateWithMicro(const Model &model, ModelType model_type,
+                                                  const std::vector<char> &weight_file, bool is_inference,
+                                                  bool enable_fp16,
+                                                  const std::vector<std::vector<char>> &changeable_weights_name);
+};
+
+Status Serialization::Load(const void *model_data, size_t data_size, ModelType model_type, Graph *graph,
+                           const Key &dec_key, const std::string &dec_mode) {
+  return Load(model_data, data_size, model_type, graph, dec_key, StringToChar(dec_mode));
+}
+
+Status Serialization::Load(const std::string &file, ModelType model_type, Graph *graph, const Key &dec_key,
+                           const std::string &dec_mode) {
+  return Load(StringToChar(file), model_type, graph, dec_key, StringToChar(dec_mode));
+}
+
+Status Serialization::Load(const std::vector<std::string> &files, ModelType model_type, std::vector<Graph> *graphs,
+                           const Key &dec_key, const std::string &dec_mode) {
+  return Load(VectorStringToChar(files), model_type, graphs, dec_key, StringToChar(dec_mode));
+}
+
+Status Serialization::SetParameters(const std::map<std::string, Buffer> &parameters, Model *model) {
+  return SetParameters(MapStringToChar<Buffer>(parameters), model);
+}
+
+Status Serialization::ExportModel(const Model &model, ModelType model_type, const std::string &model_file,
+                                  QuantizationType quantization_type, bool export_inference_only,
+                                  std::vector<std::string> output_tensor_name) {
+  return ExportModel(model, model_type, StringToChar(model_file), quantization_type, export_inference_only,
+                     VectorStringToChar(output_tensor_name));
+}
+
+Status Serialization::ExportModel(const Model &model, ModelType model_type, Buffer *model_data,
+                                  QuantizationType quantization_type, bool export_inference_only,
+                                  const std::vector<std::string> &output_tensor_name) {
+  return ExportModel(model, model_type, model_data, quantization_type, export_inference_only,
+                     VectorStringToChar(output_tensor_name));
+}
+
+Status Serialization::ExportWeightsCollaborateWithMicro(const Model &model, ModelType model_type,
+                                                        const std::string &weight_file, bool is_inference,
+                                                        bool enable_fp16,
+                                                        const std::vector<std::string> &changeable_weights_name) {
+  return ExportWeightsCollaborateWithMicro(model, model_type, StringToChar(weight_file), is_inference, enable_fp16,
+                                           VectorStringToChar(changeable_weights_name));
+}
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_SERIALIZATION_H

mindspore/include/api/status.h

@@ -0,0 +1,192 @@
+/**
+ * Copyright 2020-2022 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 <memory>
+#include <string>
+#include <vector>
+#include <ostream>
+#include <climits>
+#include "include/api/dual_abi_helper.h"
+#include "include/api/visible.h"
+namespace mindspore {
+enum CompCode : uint32_t {
+  kCore = 0x00000000u,
+  kMD = 0x10000000u,
+  kME = 0x20000000u,
+  kMC = 0x30000000u,
+  kLite = 0xF0000000u,
+};
+
+enum StatusCode : uint32_t {
+  kSuccess = 0,
+  // Core
+  kCoreFailed = kCore | 0x1,
+
+  // MD
+  kMDOutOfMemory = kMD | 1,
+  kMDShapeMisMatch = kMD | 2,
+  kMDInterrupted = kMD | 3,
+  kMDNoSpace = kMD | 4,
+  kMDPyFuncException = kMD | 5,
+  kMDDuplicateKey = kMD | 6,
+  kMDPythonInterpreterFailure = kMD | 7,
+  kMDTDTPushFailure = kMD | 8,
+  kMDFileNotExist = kMD | 9,
+  kMDProfilingError = kMD | 10,
+  kMDBoundingBoxOutOfBounds = kMD | 11,
+  kMDBoundingBoxInvalidShape = kMD | 12,
+  kMDSyntaxError = kMD | 13,
+  kMDTimeOut = kMD | 14,
+  kMDBuddySpaceFull = kMD | 15,
+  kMDNetWorkError = kMD | 16,
+  kMDNotImplementedYet = kMD | 17,
+  // Make this error code the last one. Add new error code above it.
+  kMDUnexpectedError = kMD | 127,
+
+  // ME
+  kMEFailed = kME | 0x1,
+  kMEInvalidInput = kME | 0x2,
+
+  // MC
+  kMCFailed = kMC | 0x1,
+  kMCDeviceError = kMC | 0x2,
+  kMCInvalidInput = kMC | 0x3,
+  kMCInvalidArgs = kMC | 0x4,
+
+  // Lite  // Common error code, range: [-1, -100)
+  kLiteError = kLite | (0x0FFFFFFF & -1),            /**< Common error code. */
+  kLiteNullptr = kLite | (0x0FFFFFFF & -2),          /**< NULL pointer returned.*/
+  kLiteParamInvalid = kLite | (0x0FFFFFFF & -3),     /**< Invalid parameter.*/
+  kLiteNoChange = kLite | (0x0FFFFFFF & -4),         /**< No change. */
+  kLiteSuccessExit = kLite | (0x0FFFFFFF & -5),      /**< No error but exit. */
+  kLiteMemoryFailed = kLite | (0x0FFFFFFF & -6),     /**< Fail to create memory. */
+  kLiteNotSupport = kLite | (0x0FFFFFFF & -7),       /**< Fail to support. */
+  kLiteThreadPoolError = kLite | (0x0FFFFFFF & -8),  /**< Error occur in thread pool. */
+  kLiteUninitializedObj = kLite | (0x0FFFFFFF & -9), /**< Object is not initialized. */
+  kLiteFileError = kLite | (0x0FFFFFFF & -10),       /**< Invalid file. */
+  kLiteServiceDeny = kLite | (0x0FFFFFFF & -11),     /**< Denial of service. */
+  kLiteModelRebuild = kLite | (0x0FFFFFFF & -12),    /**< Model has been built. */
+
+  // Executor error code, range: [-100,-200)
+  kLiteOutOfTensorRange = kLite | (0x0FFFFFFF & -100),           /**< Failed to check range. */
+  kLiteInputTensorError = kLite | (0x0FFFFFFF & -101),           /**< Failed to check input tensor. */
+  kLiteReentrantError = kLite | (0x0FFFFFFF & -102),             /**< Exist executor running. */
+  kLiteLLMWaitProcessTimeOut = kLite | (0x0FFFFFFF & -103),      /**< Wait to be processed time out. */
+  kLiteLLMKVCacheNotExist = kLite | (0x0FFFFFFF & -104),         /**< KV Cache not exist. */
+  kLiteLLMRepeatRequest = kLite | (0x0FFFFFFF & -105),           /**< repeat request. */
+  kLiteLLMRequestAlreadyCompleted = kLite | (0x0FFFFFFF & -106), /**< request already complete!. */
+  kLiteLLMEngineFinalized = kLite | (0x0FFFFFFF & -107),         /**< llm engine finalized. */
+  kLiteLLMNotYetLink = kLite | (0x0FFFFFFF & -108),              /**< decoder cluster is no link with prompt. */
+  kLiteLLMAlreadyLink = kLite | (0x0FFFFFFF & -109),  /**< decoder cluster is already linked with prompt cluster! */
+  kLiteLLMLinkFailed = kLite | (0x0FFFFFFF & -110),   /**< decoder cluster link with prompt cluster failed! */
+  kLiteLLMUnlinkFailed = kLite | (0x0FFFFFFF & -111), /**< decoder cluster unlink with prompt cluster failed */
+  kLiteLLMNofiryPromptUnlinkFailed =
+    kLite | (0x0FFFFFFF & -112), /**< decoder cluster notify prompt cluster do unlink failed */
+  kLiteLLMClusterNumExceedLimit = kLite | (0x0FFFFFFF & -113), /**< cluster num exceed limit */
+  kLiteLLMProcessingLink = kLite | (0x0FFFFFFF & -114),        /**< link is current processing. */
+  kLiteLLMOutOfMemory = kLite | (0x0FFFFFFF & -115),           /**< device out of memory. */
+  kLiteLLMPrefixAlreadyExist = kLite | (0x0FFFFFFF & -116),    /**< Prefix has already existed. */
+  kLiteLLMPrefixNotExist = kLite | (0x0FFFFFFF & -117),        /**< Prefix does not exist. */
+  kLiteLLMSeqLenOverLimit = kLite | (0x0FFFFFFF & -118),       /**< Sequence length exceed limit. */
+  kLiteLLMNoFreeBlock = kLite | (0x0FFFFFFF & -119),           /**< No free block. */
+  kLiteLLMBlockOutOfMemory = kLite | (0x0FFFFFFF & -120),      /**< Block is out of memory. */
+
+  // Graph error code, range: [-200,-300)
+  kLiteGraphFileError = kLite | (0x0FFFFFFF & -200), /**< Failed to verify graph file. */
+
+  // Node error code, range: [-300,-400)
+  kLiteNotFindOp = kLite | (0x0FFFFFFF & -300),        /**< Failed to find operator. */
+  kLiteInvalidOpName = kLite | (0x0FFFFFFF & -301),    /**< Invalid operator name. */
+  kLiteInvalidOpAttr = kLite | (0x0FFFFFFF & -302),    /**< Invalid operator attr. */
+  kLiteOpExecuteFailure = kLite | (0x0FFFFFFF & -303), /**< Failed to execution operator. */
+
+  // Tensor error code, range: [-400,-500)
+  kLiteFormatError = kLite | (0x0FFFFFFF & -400), /**< Failed to checking tensor format. */
+
+  // InferShape error code, range: [-500,-600)
+  kLiteInferError = kLite | (0x0FFFFFFF & -500),   /**< Failed to infer shape. */
+  kLiteInferInvalid = kLite | (0x0FFFFFFF & -501), /**< Invalid infer shape before runtime. */
+
+  // User input param error code, range: [-600, 700)
+  kLiteInputParamInvalid = kLite | (0x0FFFFFFF & -600), /**< Invalid input param by user. */
+};
+
+class MS_API Status {
+ public:
+  Status();
+  inline Status(enum StatusCode status_code, const std::string &status_msg = "");  // NOLINT(runtime/explicit)
+  inline Status(const StatusCode code, int line_of_code, const char *file_name, const std::string &extra = "");
+
+  ~Status() = default;
+
+  enum StatusCode StatusCode() const;
+  inline std::string ToString() const;
+
+  int GetLineOfCode() const;
+  inline std::string GetFileName() const;
+  inline std::string GetErrDescription() const;
+  inline std::string SetErrDescription(const std::string &err_description);
+  inline void SetStatusMsg(const std::string &status_msg);
+
+  MS_API friend std::ostream &operator<<(std::ostream &os, const Status &s);
+
+  bool operator==(const Status &other) const;
+  bool operator==(enum StatusCode other_code) const;
+  bool operator!=(const Status &other) const;
+  bool operator!=(enum StatusCode other_code) const;
+
+  explicit operator bool() const;
+  explicit operator int() const;
+
+  static Status OK();
+
+  bool IsOk() const;
+
+  bool IsError() const;
+
+  static inline std::string CodeAsString(enum StatusCode c);
+
+ private:
+  // api without std::string
+  Status(enum StatusCode status_code, const std::vector<char> &status_msg);
+  Status(enum StatusCode code, int line_of_code, const char *file_name, const std::vector<char> &extra);
+  std::vector<char> ToCString() const;
+  std::vector<char> GetFileNameChar() const;
+  std::vector<char> GetErrDescriptionChar() const;
+  std::vector<char> SetErrDescription(const std::vector<char> &err_description);
+  void SetStatusMsgChar(const std::vector<char> &status_msg);
+  static std::vector<char> CodeAsCString(enum StatusCode c);
+
+  struct Data;
+  std::shared_ptr<Data> data_;
+};
+
+Status::Status(enum StatusCode status_code, const std::string &status_msg)
+    : Status(status_code, StringToChar(status_msg)) {}
+Status::Status(const enum StatusCode code, int line_of_code, const char *file_name, const std::string &extra)
+    : Status(code, line_of_code, file_name, StringToChar(extra)) {}
+std::string Status::ToString() const { return CharToString(ToCString()); }
+std::string Status::GetFileName() const { return CharToString(GetFileNameChar()); }
+std::string Status::GetErrDescription() const { return CharToString(GetErrDescriptionChar()); }
+std::string Status::SetErrDescription(const std::string &err_description) {
+  return CharToString(SetErrDescription(StringToChar(err_description)));
+}
+void Status::SetStatusMsg(const std::string &status_msg) { SetStatusMsgChar(StringToChar(status_msg)); }
+std::string Status::CodeAsString(enum StatusCode c) { return CharToString(CodeAsCString(c)); }
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_STATUS_H