graphengine/metadef/graph/ge_tensor.cc

/**
 * 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 "graph/ge_tensor.h"
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include "debug/ge_attr_define.h"
#include "debug/ge_util.h"
#include "framework/common/debug/ge_log.h"
#include "graph/ge_attr_value.h"
#include "graph/model_serialize.h"
#include "proto/ge_ir.pb.h"
#include "utils/attr_utils.h"
#include "utils/ge_ir_utils.h"
#include "utils/tensor_utils.h"
#include "utils/type_utils.h"

namespace ge {
namespace{
const char *const kKeyDataTypeSelfDefined = "__tensor_desc_data_type__";
const std::map<DataType, ::ge::proto::DataType> kDataTypeMap = {
    {DT_UNDEFINED, proto::DT_UNDEFINED},
    {DT_FLOAT, proto::DT_FLOAT},
    {DT_FLOAT16, proto::DT_FLOAT16},
    {DT_INT8, proto::DT_INT8},
    {DT_UINT8, proto::DT_UINT8},
    {DT_INT16, proto::DT_INT16},
    {DT_UINT16, proto::DT_UINT16},
    {DT_INT32, proto::DT_INT32},
    {DT_INT64, proto::DT_INT64},
    {DT_UINT32, proto::DT_UINT32},
    {DT_UINT64, proto::DT_UINT64},
    {DT_BOOL, proto::DT_BOOL},
    {DT_DOUBLE, proto::DT_DOUBLE},
    {DT_DUAL, proto::DT_DUAL},
    {DT_DUAL_SUB_INT8, proto::DT_DUAL_SUB_INT8},
    {DT_DUAL_SUB_UINT8, proto::DT_DUAL_SUB_UINT8},
    {DT_COMPLEX64, proto::DT_COMPLEX64},
    {DT_COMPLEX128, proto::DT_COMPLEX128},
    {DT_QINT8, proto::DT_QINT8},
    {DT_QINT16, proto::DT_QINT16},
    {DT_QINT32, proto::DT_QINT32},
    {DT_QUINT8, proto::DT_QUINT8},
    {DT_QUINT16, proto::DT_QUINT16},
    {DT_RESOURCE, proto::DT_RESOURCE},
    {DT_STRING_REF, proto::DT_STRING_REF},
    {DT_STRING, proto::DT_STRING},
};

const std::map<DataType, int> kDataTypeSelfDefinedMap = {
    {DT_DUAL, 13},  {DT_DUAL_SUB_INT8, 14}, {DT_DUAL_SUB_UINT8, 15}, {DT_COMPLEX64, 16}, {DT_COMPLEX128, 17},
    {DT_QINT8, 18}, {DT_QINT16, 19},        {DT_QINT32, 20},         {DT_QUINT8, 21},    {DT_QUINT16, 22},
};
}
 


GeShape::GeShape() { shape_def_.InitDefault(); }

// Default
GeShape::GeShape(std::vector<int64_t> s) : GeShape() {
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    for (auto i : s) {
      proto_msg->add_dim(i);
    }
  }
}

size_t GeShape::GetDimNum() const {
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    if (proto_msg->dim_size() >= 0) {
      // check whether contain -2, if true, return -1
      for (auto i : proto_msg->dim()) {
        if (i == UNKNOWN_DIM_NUM) {
          return 0;
        }
      }
      return proto_msg->dim_size();
    } else {
      return 0;
    }
  }
  return 0;
}

int64_t GeShape::GetDim(size_t idx) const {
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    if (proto_msg->dim_size() > static_cast<int>(idx)) {
      return proto_msg->dim(static_cast<int>(idx));
    }
  }
  return 0;
}

graphStatus GeShape::SetDim(size_t idx, int64_t value) {
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    auto dims = proto_msg->mutable_dim();
    GE_CHECK_NOTNULL(dims);
    if (dims->empty()) {
      GELOGE(GRAPH_FAILED, "shape is empty");
      return GRAPH_FAILED;
    }
    if (static_cast<int>(idx) >= dims->size()) {
      GELOGE(GRAPH_FAILED, "idx is out of range");
      return GRAPH_FAILED;
    }
    proto_msg->set_dim(static_cast<int>(idx), value);
  }
  return GRAPH_SUCCESS;
}

std::vector<int64_t> GeShape::GetDims() const {
  vector<int64_t> dims;
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    for (auto i : proto_msg->dim()) {
      dims.push_back(i);
    }
  }
  return dims;
}

std::string GeShape::ToString() const {
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg == nullptr) {
    return "";
  }

  std::stringstream ss;
  bool first = true;
  for (auto i : proto_msg->dim()) {
    if (first) {
      first = false;
    } else {
      ss << ",";
    }
    ss << i;
  }
  return ss.str();
}

int64_t GeShape::GetShapeSize() const {
  int64_t res = 1;
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    if (proto_msg->dim().empty()) {
      return 0;
    }
    for (auto i : proto_msg->dim()) {
      // if unknown shape, return -1
      if (i == UNKNOWN_DIM || i == UNKNOWN_DIM_NUM) {
        return UNKNOWN_DIM;
      }
      res *= i;
    }
  }
  return res;
}

///
/// @brief Check is unknown shape
/// @return bool
/// ///
bool GeShape::IsUnknownShape() const {
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    for (auto i : proto_msg->dim()) {
      if (i < 0) {
        return true;
      }
    }
  }
  return false;
}

///
/// @brief Check is a scalar
/// @return bool
///
bool GeShape::IsScalar() const {
  auto proto_msg = shape_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    return proto_msg->dim().empty();
  }
  return false;
}

const string TENSOR_UTILS_SIZE = "size";
const string TENSOR_UTILS_WEIGHT_SIZE = "weight_size";
const string TENSOR_UTILS_REUSE_INPUT = "reuse_input";
const string TENSOR_UTILS_OUTPUT_TENSOR = "output_tensor";
const string TENSOR_UTILS_DEVICE_TYPE = "device_type";
const string TENSOR_UTILS_INPUT_TENSOR = "input_tensor";
const string TENSOR_UTILS_REAL_DIM_CNT = "real_dim_cnt";
const string TENSOR_UTILS_REUSE_INPUT_INDEX = "reuse_input_index";
const string TENSOR_UTILS_DATA_OFFSET = "data_offset";
const string TENSOR_UTILS_CMPS_SIZE = "cmps_size";
const string TENSOR_UTILS_CMPS_TAB = "cmps_tab";
const string TENSOR_UTILS_CMPS_TAB_OFFSET = "cmps_tab_offset";
const string TENSOR_UTILS_CMPSINFO = "cmps_info";
const string TENSOR_UTILS_ALLOFFSET_QUANTIZE_INFO = "alloffset_quantize_info";
const string TENSOR_UTILS_RC = "rc";
const string TENSOR_UTILS_ORIGIN_SHAPE = "origin_shape";
const string TENSOR_UTILS_ORIGIN_FORMAT = "origin_format";
const string TENSOR_UTILS_ORIGIN_DATA_TYPE = "origin_data_type";
const string TENSOR_UTILS_SHAPE_RANGE = "shape_range";
const string TENSOR_UTILS_REF_PORT_INDEX = "ref_port_index";

GeShape::GeShape(const ProtoMsgOwner &proto_owner, proto::ShapeDef *proto_msg) : shape_def_(proto_owner, proto_msg) {}

GeShape::GeShape(const GeShape &other) : GeShape() { shape_def_.CopyValueFrom(other.shape_def_); }

GeShape::GeShape(GeShape &&other) : GeShape() { shape_def_.MoveValueFrom(std::move(other.shape_def_)); }

GeShape &GeShape::operator=(const GeShape &other) {
  if (&other != this) {
    shape_def_.CopyValueFrom(other.shape_def_);
  }
  return *this;
}

GeShape &GeShape::operator=(GeShape &&other) {
  if (&other != this) {
    shape_def_.CopyValueFrom(std::move(other.shape_def_));
  }
  return *this;
}

GeTensorDesc::GeTensorDesc() {
  tensor_descriptor_.InitDefault();
  SetDataType(DT_FLOAT);
  Init();
}

// Default
GeTensorDesc::GeTensorDesc(GeShape shape, Format format, DataType dt) : GeTensorDesc() {
  SetFormat(format);
  SetDataType(dt);
  ShapeReference() = std::move(shape);
}

// Default
GeTensorDesc::GeTensorDesc(const GeTensorDesc &desc) : GeTensorDesc() {
  tensor_descriptor_.CopyValueFrom(desc.tensor_descriptor_);
}

// Default
GeTensorDesc::GeTensorDesc(GeTensorDesc &&desc) : GeTensorDesc() {
  tensor_descriptor_.MoveValueFrom(std::move(desc.tensor_descriptor_));
}

GeTensorDesc::GeTensorDesc(const ProtoMsgOwner &proto_owner, proto::TensorDescriptor *proto_msg)
    : tensor_descriptor_(proto_owner, proto_msg) {
  if (proto_msg != nullptr && !proto_msg->has_out_attr()) {
    proto_msg->set_has_out_attr(true);

    int64_t size = 0;
    (void)AttrUtils::GetInt(this, TENSOR_UTILS_SIZE, size);
    proto_msg->set_size(size);

    int64_t weight_size = 0;
    (void)AttrUtils::GetInt(this, TENSOR_UTILS_WEIGHT_SIZE, weight_size);
    proto_msg->set_weight_size(weight_size);

    bool reuse_input = false;
    (void)AttrUtils::GetBool(this, TENSOR_UTILS_REUSE_INPUT, reuse_input);
    proto_msg->set_reuse_input(reuse_input);

    bool output_tensor = false;
    (void)AttrUtils::GetBool(this, TENSOR_UTILS_OUTPUT_TENSOR, output_tensor);
    proto_msg->set_output_tensor(output_tensor);

    string device_type = "NPU";
    (void)AttrUtils::GetStr(this, TENSOR_UTILS_DEVICE_TYPE, device_type);
    proto_msg->set_device_type(device_type);

    bool input_tensor = false;
    (void)AttrUtils::GetBool(this, TENSOR_UTILS_INPUT_TENSOR, input_tensor);
    proto_msg->set_input_tensor(input_tensor);

    int64_t real_dim_cnt = 0;
    (void)AttrUtils::GetInt(this, TENSOR_UTILS_REAL_DIM_CNT, real_dim_cnt);
    proto_msg->set_real_dim_cnt(real_dim_cnt);

    int64_t reuse_input_index = 0;
    (void)AttrUtils::GetInt(this, TENSOR_UTILS_REUSE_INPUT_INDEX, reuse_input_index);
    proto_msg->set_reuse_input_index(reuse_input_index);

    int64_t data_offset = 0;
    (void)AttrUtils::GetInt(this, TENSOR_UTILS_DATA_OFFSET, data_offset);
    proto_msg->set_data_offset(data_offset);

    int64_t cmps_size = 0;
    (void)AttrUtils::GetInt(this, TENSOR_UTILS_CMPS_SIZE, cmps_size);
    proto_msg->set_cmps_size(cmps_size);

    string cmps_tab;
    (void)AttrUtils::GetStr(this, TENSOR_UTILS_CMPS_TAB, cmps_tab);
    proto_msg->set_cmps_tab(cmps_tab);

    int64_t cmps_tab_offset = 0;
    (void)AttrUtils::GetInt(this, TENSOR_UTILS_CMPS_TAB_OFFSET, cmps_tab_offset);
    proto_msg->set_cmps_tab_offset(cmps_tab_offset);
  }
}

bool GeTensorDesc::GeTensorDescAttrsAreEqual(const GeTensorDesc &r_ge_tensor_desc) const {
  const auto &tensor_descriptor = this->tensor_descriptor_.GetProtoMsg();
  const auto &r_tensor_descriptor = r_ge_tensor_desc.tensor_descriptor_.GetProtoMsg();
  if ((tensor_descriptor != nullptr) && (r_tensor_descriptor != nullptr)) {
    // Message TensorDescriptor in ge_ir.proto
    return (IsEqual(tensor_descriptor->name(), r_tensor_descriptor->name(), "TensorDescriptor.name()") &&
            IsEqual(tensor_descriptor->dtype(), r_tensor_descriptor->dtype(), "TensorDescriptor.dtype()") &&
            // Message ShapeDef in ge_ir.proto
            IsEqual(ToString(tensor_descriptor->shape().dim()), ToString(r_tensor_descriptor->shape().dim()),
                    "TensorDescriptor.shape().dim()") &&
            IsEqual(tensor_descriptor->layout(), r_tensor_descriptor->layout(), "TensorDescriptor.layout()") &&
            IsEqual(tensor_descriptor->has_out_attr(), r_tensor_descriptor->has_out_attr(),
                    "TensorDescriptor.has_out_attr()") &&
            IsEqual(tensor_descriptor->size(), r_tensor_descriptor->size(), "TensorDescriptor.size()") &&
            IsEqual(tensor_descriptor->weight_size(), r_tensor_descriptor->weight_size(),
                    "TensorDescriptor.weight_size()") &&
            IsEqual(tensor_descriptor->reuse_input(), r_tensor_descriptor->reuse_input(),
                    "TensorDescriptor.reuse_input()") &&
            IsEqual(tensor_descriptor->output_tensor(), r_tensor_descriptor->output_tensor(),
                    "TensorDescriptor.output_tensor()") &&
            IsEqual(tensor_descriptor->device_type(), r_tensor_descriptor->device_type(),
                    "TensorDescriptor.device_type()") &&
            IsEqual(tensor_descriptor->input_tensor(), r_tensor_descriptor->input_tensor(),
                    "TensorDescriptor.input_tensor()") &&
            IsEqual(tensor_descriptor->real_dim_cnt(), r_tensor_descriptor->real_dim_cnt(),
                    "TensorDescriptor.real_dim_cnt()") &&
            IsEqual(tensor_descriptor->reuse_input_index(), r_tensor_descriptor->reuse_input_index(),
                    "TensorDescriptor.reuse_input_index()") &&
            IsEqual(tensor_descriptor->data_offset(), r_tensor_descriptor->data_offset(),
                    "TensorDescriptor.data_offset()") &&
            IsEqual(tensor_descriptor->cmps_size(), r_tensor_descriptor->cmps_size(), "TensorDescriptor.cmps_size()") &&
            IsEqual(tensor_descriptor->cmps_tab(), r_tensor_descriptor->cmps_tab(), "TensorDescriptor.cmps_tab()") &&
            IsEqual(tensor_descriptor->cmps_tab_offset(), r_tensor_descriptor->cmps_tab_offset(),
                    "TensorDescriptor.cmps_tab_offset()"));
  } else {
    return ((tensor_descriptor == nullptr) && (r_tensor_descriptor == nullptr));
  }
}

bool GeTensorDesc::operator==(const GeTensorDesc &r_ge_tensor_desc) const {
  return GeTensorDescAttrsAreEqual(r_ge_tensor_desc);
}

GeShape &GeTensorDesc::ShapeReference() const {
  if (tensor_descriptor_.GetProtoMsg() != nullptr) {
    GeShape refShape(tensor_descriptor_.GetProtoOwner(), tensor_descriptor_.GetProtoMsg()->mutable_shape());
    __shape_.RefTo(refShape);
  } else {
    GeShape refShape(tensor_descriptor_.GetProtoOwner(), nullptr);
    __shape_.RefTo(refShape);
  }
  return __shape_;
}

void GeTensorDesc::Init() {
  SetFormat(FORMAT_ND);
  SetOriginFormat(FORMAT_ND);
  TensorUtils::SetDeviceType(*this, DeviceType::NPU);
  if (tensor_descriptor_.GetProtoMsg() == nullptr) {
    GELOGE(GRAPH_FAILED, "ProtoType nullptr.");
    return;
  }
  tensor_descriptor_.GetProtoMsg()->set_has_out_attr(true);
}

ProtoAttrMapHelper GeTensorDesc::MutableAttrMap() {
  if (tensor_descriptor_.GetProtoMsg() != nullptr) {
    return ProtoAttrMapHelper(tensor_descriptor_.GetProtoOwner(), tensor_descriptor_.GetProtoMsg()->mutable_attr());
  }
  return ProtoAttrMapHelper(tensor_descriptor_.GetProtoOwner(), nullptr);
}

ConstProtoAttrMapHelper GeTensorDesc::GetAttrMap() const {
  if (tensor_descriptor_.GetProtoMsg() != nullptr) {
    return ConstProtoAttrMapHelper(tensor_descriptor_.GetProtoOwner(),
                                   tensor_descriptor_.GetProtoMsg()->mutable_attr());
  }
  return ConstProtoAttrMapHelper(tensor_descriptor_.GetProtoOwner(), nullptr);
}

void GeTensorDesc::Update(GeShape shape, Format format, DataType dt) {
  ShapeReference() = std::move(shape);
  SetFormat(format);
  SetDataType(dt);
}
GeShape GeTensorDesc::GetShape() const { return ShapeReference(); }

GeShape &GeTensorDesc::MutableShape() { return ShapeReference(); }

void GeTensorDesc::SetShape(GeShape shape) { ShapeReference() = std::move(shape); }

// set shape with -2, it stand for unknown shape
void GeTensorDesc::SetUnknownDimNumShape() { SetShape(GeShape({UNKNOWN_DIM_NUM})); }

// for unknown shape
graphStatus GeTensorDesc::SetShapeRange(const std::vector<std::pair<int64_t, int64_t>> &range) {
  std::vector<vector<int64_t>> shape_range;
  for (const auto &ele : range) {
    shape_range.emplace_back(std::vector<int64_t>({ele.first, ele.second}));
  }
  auto ret = AttrUtils::SetListListInt(this, TENSOR_UTILS_SHAPE_RANGE, shape_range);
  return ret ? GRAPH_SUCCESS : GRAPH_FAILED;
}
graphStatus GeTensorDesc::GetShapeRange(std::vector<std::pair<int64_t, int64_t>> &range) const {
  std::vector<vector<int64_t>> shape_range;
  (void)AttrUtils::GetListListInt(this, TENSOR_UTILS_SHAPE_RANGE, shape_range);

  for (const auto &ele : shape_range) {
    // here must be only two elemenet because pair
    if (ele.size() != 2) {
      GELOGE(GRAPH_FAILED, "shape_range must contain only 2 value but really is %lu", ele.size());
      return GRAPH_FAILED;
    }
    std::pair<int64_t, int64_t> pair({ele[0], ele[1]});
    range.emplace_back(pair);
  }

  return GRAPH_SUCCESS;
}

GeShape GeTensorDesc::GetOriginShape() const {
  vector<int64_t> origin_shape;
  if (!AttrUtils::GetListInt(this, TENSOR_UTILS_ORIGIN_SHAPE, origin_shape)) {
    return GeShape();
  }
  return GeShape(origin_shape);
}

void GeTensorDesc::SetOriginShape(const GeShape &origin_shape) {
  std::vector<int64_t> origin_shape_tmp = origin_shape.GetDims();
  (void)AttrUtils::SetListInt(this, TENSOR_UTILS_ORIGIN_SHAPE, origin_shape_tmp);
}

Format GeTensorDesc::GetFormat() const {
  auto tensor_descriptor_msg = tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    return TypeUtils::SerialStringToFormat(tensor_descriptor_msg->layout());
  }
  return FORMAT_RESERVED;
}

void GeTensorDesc::SetFormat(Format format) {
  auto tensor_descriptor_msg = tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_layout(TypeUtils::FormatToSerialString(format));
  }
}

void GeTensorDesc::SetName(const std::string &name) {
  auto tensor_descriptor_msg = tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_name(name);
    return;
  }
  GELOGW("[SetName]tensor_descriptor_msg is null.");
}

const std::string GeTensorDesc::GetName() const {
  auto tensor_descriptor_msg = tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    return tensor_descriptor_msg->name();
  }
  GELOGW("[GetName]tensor_descriptor_msg is null.");
  return "";
}

Format GeTensorDesc::GetOriginFormat() const {
  std::string origin_format_str;
  if (!AttrUtils::GetStr(this, TENSOR_UTILS_ORIGIN_FORMAT, origin_format_str)) {
    // Can not get the certificate and it's not set, return directly
    return FORMAT_RESERVED;
  }
  if (origin_format_str == "RESERVED") {
    return FORMAT_RESERVED;
  }
  return TypeUtils::SerialStringToFormat(origin_format_str);
}

void GeTensorDesc::SetOriginFormat(Format origin_format) {
  std::string origin_format_str = "RESERVED";
  if (origin_format != FORMAT_RESERVED) {
    origin_format_str = TypeUtils::FormatToSerialString(origin_format);
  }
  (void)AttrUtils::SetStr(this, TENSOR_UTILS_ORIGIN_FORMAT, origin_format_str);
}

DataType GeTensorDesc::GetDataType() const {
  auto tensor_descriptor_msg = tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg == nullptr) {
    return DT_UNDEFINED;
  }
  auto &attr_map = *(tensor_descriptor_msg->mutable_attr());
  // Data type
  auto it_data_type = attr_map.find(kKeyDataTypeSelfDefined);
  if (it_data_type != attr_map.end()) {
    int64_t data_type_proto = it_data_type->second.i();
    for (auto it : kDataTypeSelfDefinedMap) {
      if (it.second == data_type_proto) {
        return it.first;
      }
    }
  } else {
    auto data_type_proto = tensor_descriptor_msg->dtype();
    for (auto it : kDataTypeMap) {
      if (it.second == data_type_proto) {
        return it.first;
      }
    }
  }
  return DT_UNDEFINED;
}

void GeTensorDesc::SetDataType(DataType dataType) {
  auto tensor_descriptor_msg = tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg == nullptr) {
    return;
  }
  auto &attr_maps = *(tensor_descriptor_msg->mutable_attr());
  (void)attr_maps.erase(kKeyDataTypeSelfDefined);

  // Data type
  auto it = kDataTypeMap.find(dataType);
  if (it != kDataTypeMap.end()) {
    tensor_descriptor_msg->set_dtype(it->second);
    return;
  }
  auto it2 = kDataTypeSelfDefinedMap.find(dataType);
  if (it2 != kDataTypeSelfDefinedMap.end()) {
    attr_maps[kKeyDataTypeSelfDefined].set_i(it2->second);
  }
}

void GeTensorDesc::SetOriginDataType(DataType origin_data_type) {
  std::string origin_data_type_str = "RESERVED";
  if (origin_data_type != DT_UNDEFINED) {
    origin_data_type_str = TypeUtils::DataTypeToSerialString(origin_data_type);
  }
  (void)AttrUtils::SetStr(this, TENSOR_UTILS_ORIGIN_DATA_TYPE, origin_data_type_str);
}

DataType GeTensorDesc::GetOriginDataType() const {
  std::string origin_data_type_str;
  if (!AttrUtils::GetStr(this, TENSOR_UTILS_ORIGIN_DATA_TYPE, origin_data_type_str)) {
    return DT_UNDEFINED;
  }
  if (origin_data_type_str == "RESERVED") {
    return DT_UNDEFINED;
  }
  return TypeUtils::SerialStringToDataType(origin_data_type_str);
}

std::vector<uint32_t> GeTensorDesc::GetRefPortIndex() const {
  vector<uint32_t> ref_port_index;
  (void)AttrUtils::GetListInt(this, TENSOR_UTILS_REF_PORT_INDEX, ref_port_index);
  return ref_port_index;
}

void GeTensorDesc::SetRefPortByIndex(const std::vector<uint32_t> &index) {
  (void)AttrUtils::SetListInt(this, TENSOR_UTILS_REF_PORT_INDEX, index);
}

graphStatus GeTensorDesc::IsValid() const {
  auto dtype = this->GetDataType();
  auto format = this->GetFormat();
  if (dtype == DT_UNDEFINED && format == FORMAT_RESERVED) {
    return GRAPH_PARAM_INVALID;
  }
  return GRAPH_SUCCESS;
}

GeTensorDesc GeTensorDesc::Clone() const { return *this; }

GeTensorDesc &GeTensorDesc::operator=(const GeTensorDesc &desc) {
  if (&desc != this) {
    tensor_descriptor_.CopyValueFrom(desc.tensor_descriptor_);
  }
  return *this;
}

GeTensorDesc &GeTensorDesc::operator=(GeTensorDesc &&desc) {
  if (&desc != this) {
    tensor_descriptor_.CopyValueFrom(std::move(desc.tensor_descriptor_));
  }
  return *this;
}

GeTensor::GeTensor::GeTensor() {
  tensor_def_.InitDefault();
  // Default init desc
  DescReference() = GeTensorDesc();
}

GeTensor::GeTensor(const GeTensorDesc &tensor_desc) : GeTensor() { DescReference() = tensor_desc; }

GeTensor::GeTensor(const GeTensorDesc &tensor_desc, const vector<uint8_t> &data) : GeTensor() {
  DescReference() = tensor_desc;
  auto proto_msg = tensor_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    proto_msg->set_data(data.data(), data.size());
  }
}

GeTensor::GeTensor(const GeTensorDesc &tensor_desc, const uint8_t *data, size_t size) : GeTensor() {
  DescReference() = tensor_desc;
  auto proto_msg = tensor_def_.GetProtoMsg();
  if (proto_msg != nullptr && data != nullptr) {
    proto_msg->set_data(data, size);
  }
}

GeTensor::GeTensor(GeTensorDesc &&tensor_desc, vector<uint8_t> &&data) : GeTensor() {
  DescReference() = std::move(tensor_desc);
  auto proto_msg = tensor_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    proto_msg->set_data(data.data(), data.size());
  }
}

GeTensor::GeTensor(const GeTensorDesc &tensor_desc, const Buffer &data) : GeTensor() {
  DescReference() = tensor_desc;
  auto proto_msg = tensor_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    if (data.size() == 0) {
      GELOGI("GetSize res is 0.");
    }
    if (data.data() == nullptr) {
      GELOGI("data addr is null.");
    }
    proto_msg->set_data(data.GetData(), data.GetSize());
  }
}

GeTensor::GeTensor(const ProtoMsgOwner &proto_owner, proto::TensorDef *proto_msg)
    : tensor_def_(proto_owner, proto_msg) {}

GeTensorDesc GeTensor::GetTensorDesc() const { return DescReference(); }

GeTensorDesc &GeTensor::MutableTensorDesc() { return DescReference(); }

GeTensorDesc &GeTensor::DescReference() const {
  if (tensor_def_.GetProtoMsg() != nullptr) {
    GeTensorDesc tensor_desc(tensor_def_.GetProtoOwner(), tensor_def_.GetProtoMsg()->mutable_desc());
    __desc_.RefTo(tensor_desc);
  } else {
    GeTensorDesc tensor_desc(tensor_def_.GetProtoOwner(), nullptr);
    __desc_.RefTo(tensor_desc);
  }
  return __desc_;
}

void GeTensor::SetTensorDesc(const GeTensorDesc &tensor_desc) { DescReference() = tensor_desc; }

const Buffer GeTensor::GetData() const {
  auto proto_msg = tensor_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    return Buffer(tensor_def_.GetProtoOwner(), proto_msg->mutable_data());
  }
  return Buffer();
}

Buffer GeTensor::MutableData() {
  auto proto_msg = tensor_def_.GetProtoMsg();
  if (proto_msg != nullptr) {
    return Buffer(tensor_def_.GetProtoOwner(), proto_msg->mutable_data());
  }
  return Buffer();
}

graphStatus GeTensor::SetData(vector<uint8_t> &&data) {
  auto proto_msg = tensor_def_.GetProtoMsg();
  GE_CHECK_NOTNULL(proto_msg);
  proto_msg->set_data(data.data(), data.size());
  return GRAPH_SUCCESS;
}

graphStatus GeTensor::SetData(const vector<uint8_t> &data) {
  auto proto_msg = tensor_def_.GetProtoMsg();
  GE_CHECK_NOTNULL(proto_msg);
  proto_msg->set_data(data.data(), data.size());
  return GRAPH_SUCCESS;
}

graphStatus GeTensor::SetData(const uint8_t *data, size_t size) {
  if (size > 0) {
    GE_CHECK_NOTNULL(data);
  }
  auto proto_msg = tensor_def_.GetProtoMsg();
  GE_CHECK_NOTNULL(proto_msg);
  proto_msg->set_data(data, size);
  return GRAPH_SUCCESS;
}

graphStatus GeTensor::SetData(const Buffer &data) {
  auto proto_msg = tensor_def_.GetProtoMsg();
  GE_CHECK_NOTNULL(proto_msg);
  if (data.size() == 0) {
    GELOGI("GetSize res is 0.");
  }
  if (data.data() == nullptr) {
    GELOGI("data addr is null.");
  }
  proto_msg->set_data(data.data(), data.size());
  return GRAPH_SUCCESS;
}

GeTensor GeTensor::Clone() const {
  GeTensor tensor;
  tensor.tensor_def_.CopyValueFrom(tensor_def_);
  return tensor;
}

GeTensor::GeTensor(const GeTensor &other) { tensor_def_ = other.tensor_def_; }

GeTensor &GeTensor::operator=(const GeTensor &other) {
  if (&other != this) {
    tensor_def_ = other.tensor_def_;
  }
  return *this;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetSize(const GeTensorDesc &tensor_desc,
                                                                                int64_t &size) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  GE_CHECK_NOTNULL(tensor_descriptor_msg);
  size = static_cast<int64_t>(tensor_descriptor_msg->size());
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetSize(GeTensorDesc &tensor_desc, int64_t size) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_size(size);
  }
}

uint32_t TensorUtils::GetWeightSize(const GeTensorDesc &tensor_desc) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    return static_cast<uint32_t>(tensor_descriptor_msg->weight_size());
  }
  return 0;
}

uint32_t TensorUtils::GetWeightSize(const GeTensor &tensor) { return GetWeightSize(tensor.GetTensorDesc()); }

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY uint32_t TensorUtils::GetWeightSize(const ConstGeTensorPtr &tensor_ptr) {
  if (tensor_ptr == nullptr) {
    return 0;
  }
  return GetWeightSize(*tensor_ptr);
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY uint8_t *TensorUtils::GetWeightAddr(const ConstGeTensorPtr &tensor_ptr,
                                                                                   uint8_t *base) {
  if (tensor_ptr == nullptr) {
    GELOGE(GRAPH_FAILED, "tensor_ptr is null.");
    return nullptr;
  }
  return GetWeightAddr(*tensor_ptr, base);
}

uint8_t *TensorUtils::GetWeightAddr(const GeTensor &tensor, uint8_t *base) {
  if (base == nullptr) {
    GELOGE(GRAPH_FAILED, "base is null.");
    return nullptr;
  }
  int64_t weight_data_offset = 0;
  if (GetDataOffset(tensor.GetTensorDesc(), weight_data_offset) != GRAPH_SUCCESS) return nullptr;

  if (weight_data_offset == 0) {
    // The weight of offset 0 is still in const op, still get from ATTR_NAME_WEIGHTS.
    return const_cast<uint8_t *>(tensor.GetData().data());
  }

  return base + weight_data_offset;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetWeightSize(GeTensorDesc &tensor_desc,
                                                                               uint32_t size) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_weight_size(size);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetReuseInput(const GeTensorDesc &tensor_desc,
                                                                                      bool &flag) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  GE_CHECK_NOTNULL(tensor_descriptor_msg);
  flag = tensor_descriptor_msg->reuse_input();
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetReuseInput(GeTensorDesc &tensor_desc, bool flag) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_reuse_input(flag);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetOutputTensor(const GeTensorDesc &tensor_desc,
                                                                                        bool &flag) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  GE_CHECK_NOTNULL(tensor_descriptor_msg);
  flag = tensor_descriptor_msg->output_tensor();
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetOutputTensor(GeTensorDesc &tensor_desc, bool flag) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_output_tensor(flag);
  }
}

static map<uint32_t, string> device_to_str_map{
    {0, "NPU"}, {1, "CPU"},
};
static map<string, uint32_t> str_to_device_map{
    {"NPU", 0}, {"CPU", 1},
};

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetDeviceType(const GeTensorDesc &tensor_desc,
                                                                                      DeviceType &type) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  GE_CHECK_NOTNULL(tensor_descriptor_msg);
  string type_str = tensor_descriptor_msg->device_type();
  type = DeviceType(str_to_device_map[type_str]);
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetDeviceType(GeTensorDesc &tensor_desc,
                                                                               DeviceType type) {
  auto type_str = device_to_str_map[type];
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_device_type(type_str);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetInputTensor(const GeTensorDesc &tensor_desc,
                                                                                       bool &flag) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  GE_CHECK_NOTNULL(tensor_descriptor_msg);
  flag = tensor_descriptor_msg->input_tensor();
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetInputTensor(GeTensorDesc &tensor_desc, bool flag) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_input_tensor(flag);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetRealDimCnt(const GeTensorDesc &tensor_desc,
                                                                                      uint32_t &cnt) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  GE_CHECK_NOTNULL(tensor_descriptor_msg);
  cnt = static_cast<uint32_t>(tensor_descriptor_msg->real_dim_cnt());
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetRealDimCnt(GeTensorDesc &tensor_desc,
                                                                               uint32_t cnt) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_real_dim_cnt(cnt);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus
TensorUtils::GetReuseInputIndex(const GeTensorDesc &tensor_desc, uint32_t &idx) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  GE_CHECK_NOTNULL(tensor_descriptor_msg);

  idx = static_cast<uint32_t>(tensor_descriptor_msg->reuse_input_index());
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetReuseInputIndex(GeTensorDesc &tensor_desc,
                                                                                    uint32_t idx) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_reuse_input_index(idx);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetDataOffset(const GeTensorDesc &tensor_desc,
                                                                                      int64_t &offset) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    offset = tensor_descriptor_msg->data_offset();
    return GRAPH_SUCCESS;
  } else {
    GELOGW("tensor_descriptor_msg is nullptr.");
    return GRAPH_FAILED;
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetDataOffset(GeTensorDesc &tensor_desc,
                                                                               int64_t offset) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_data_offset(offset);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetCmpsSize(const GeTensorDesc &tensor_desc,
                                                                                    uint32_t &cmp_size) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    cmp_size = static_cast<uint32_t>(tensor_descriptor_msg->cmps_size());
  }
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetCmpsSize(GeTensorDesc &tensor_desc,
                                                                             uint32_t cmp_size) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_cmps_size(cmp_size);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetCmpsTab(const GeTensorDesc &tensor_desc,
                                                                                   vector<uint8_t> &vec) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    string str = tensor_descriptor_msg->cmps_tab();
    vec.assign(str.begin(), str.end());
  }
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetCmpsTab(GeTensorDesc &tensor_desc,
                                                                            const uint8_t *data, size_t size) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    GE_CHK_BOOL_EXEC(data != nullptr, return, "data is null.");
    string str((const char *)data, size);
    tensor_descriptor_msg->set_cmps_tab(str);
  }
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus
TensorUtils::GetCmpsTabOffset(const GeTensorDesc &tensor_desc, int64_t &tab_offset) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tab_offset = tensor_descriptor_msg->cmps_tab_offset();
  }
  return GRAPH_SUCCESS;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetCmpsTabOffset(GeTensorDesc &tensor_desc,
                                                                                  int64_t tab_offset) {
  auto tensor_descriptor_msg = tensor_desc.tensor_descriptor_.GetProtoMsg();
  if (tensor_descriptor_msg != nullptr) {
    tensor_descriptor_msg->set_cmps_tab_offset(tab_offset);
  }
}

graphStatus TensorUtils::GetCmpsInfo(const GeTensorDesc &tensor_desc, CompressInfo &info) {
  GeAttrValue attr_value;
  if (tensor_desc.GetAttr(TENSOR_UTILS_CMPSINFO, attr_value) != GRAPH_SUCCESS) {
    return GRAPH_FAILED;
  }
  return attr_value.GetValue(info);
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetCmpsInfo(GeTensorDesc &tensor_desc,
                                                                             const CompressInfo &info) {
  (void)tensor_desc.SetAttr(TENSOR_UTILS_CMPSINFO, GeAttrValue::CreateFrom(info));
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool TensorUtils::HasAlloffsetQuantizeInfo(
    const GeTensorDesc &tensor_desc) {
  return tensor_desc.HasAttr(TENSOR_UTILS_ALLOFFSET_QUANTIZE_INFO);
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus
TensorUtils::GetAlloffsetQuantizeInfo(const GeTensorDesc &tensor_desc, AllOffsetQuantizeInfo &info) {
  GeAttrValue attr_value;
  if (tensor_desc.GetAttr(TENSOR_UTILS_ALLOFFSET_QUANTIZE_INFO, attr_value) != GRAPH_SUCCESS) {
    GELOGW("get attr alloffset_quantize_info fail.");
  }
  return attr_value.GetValue(info);
}

void TensorUtils::SetAlloffsetQuantizeInfo(GeTensorDesc &tensor_desc, const AllOffsetQuantizeInfo &info) {
  (void)tensor_desc.SetAttr(TENSOR_UTILS_ALLOFFSET_QUANTIZE_INFO, GeAttrValue::CreateFrom(info));
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY graphStatus TensorUtils::GetRC(const GeTensorDesc &tensor_desc,
                                                                              uint32_t &rc) {
  return AttrUtils::GetInt(&tensor_desc, TENSOR_UTILS_RC, rc) ? GRAPH_SUCCESS : GRAPH_FAILED;
}

GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY void TensorUtils::SetRC(GeTensorDesc &tensor_desc, uint32_t rc) {
  (void)AttrUtils::SetInt(&tensor_desc, TENSOR_UTILS_RC, rc);
}
}  // namespace ge