hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 8896282c88
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8896282c88'
${ noResults }
graphengine/metadef/graph/ge_attr_value.cc

1290 lines
57 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019-2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. 

  17. #include "graph/ge_attr_value.h"

  18. #include "graph/ge_tensor.h"

  19. #include "external/graph/graph.h"

  20. #include "utils/attr_utils.h"

  21. #include "framework/common/debug/ge_log.h"

  22. #include "graph/model_serialize.h"

  23. #include "proto/ge_ir.pb.h"

  24. #include "detail/model_serialize_imp.h"

  25. #include "debug/ge_attr_define.h"

  26. #include "debug/ge_log.h"

  27. #include "debug/ge_util.h"

  28. 

  29. using std::map;

  30. using std::string;

  31. using std::vector;

  32. 

  33. namespace ge {

  34. NamedAttrs::NamedAttrs() { named_attrs_.InitDefault(); }

  35. 

  36. NamedAttrs::NamedAttrs(const ProtoMsgOwner &owner, proto::NamedAttrs *proto_msg)

  37.     : named_attrs_(owner, proto_msg) {}  // lint !e1744

  38. 

  39. void NamedAttrs::SetName(const std::string &name) {

  40.   auto proto_msg = named_attrs_.GetProtoMsg();

  41.   if (proto_msg != nullptr) {

  42.     proto_msg->set_name(name);

  43.   }

  44. }

  45. 

  46. string NamedAttrs::GetName() const {

  47.   auto proto_msg = named_attrs_.GetProtoMsg();

  48.   if (proto_msg != nullptr) {

  49.     return proto_msg->name();

  50.   }

  51.   return string();

  52. }

  53. 

  54. GeAttrValue NamedAttrs::GetItem(const string &key) const {

  55.   GeAttrValue value;

  56.   (void)GetAttr(key, value);

  57.   return value;

  58. }

  59. 

  60. ProtoAttrMapHelper NamedAttrs::MutableAttrMap() {

  61.   auto proto_msg = named_attrs_.GetProtoMsg();

  62.   if (proto_msg != nullptr) {

  63.     return ProtoAttrMapHelper(named_attrs_.GetProtoOwner(), proto_msg->mutable_attr());

  64.   }

  65.   return ProtoAttrMapHelper(named_attrs_.GetProtoOwner(), nullptr);

  66. }

  67. 

  68. ConstProtoAttrMapHelper NamedAttrs::GetAttrMap() const {

  69.   auto proto_msg = named_attrs_.GetProtoMsg();

  70.   if (proto_msg != nullptr) {

  71.     return ConstProtoAttrMapHelper(named_attrs_.GetProtoOwner(), &proto_msg->attr());

  72.   }

  73.   return ConstProtoAttrMapHelper(named_attrs_.GetProtoOwner(), nullptr);

  74. }

  75. 

  76. class GeAttrValueImp {

  77.  public:

  78.   static map<proto::AttrDef::ValueCase, GeAttrValue::ValueType> attr_val_one_type_map_;

  79.   static map<proto::AttrDef_ListValue_ListValueType, GeAttrValue::ValueType> attr_val_list_type_map_;

  80. 

  81.   static bool SetValue(proto::AttrDef &attr_def, GeAttrValue::INT val);

  82.   static bool SetValue(proto::AttrDef &attr_def, GeAttrValue::FLOAT val);

  83.   static bool SetValue(proto::AttrDef &attr_def, GeAttrValue::BOOL val);

  84.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::STR &val);

  85.   static bool SetValue(proto::AttrDef &attr_def, const ConstGeTensorPtr &val);

  86.   static bool SetValue(proto::AttrDef &attr_def, const GeTensor &val);

  87.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::TENSOR_DESC &val);

  88.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::BYTES &val);

  89.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::NAMED_ATTRS &val);

  90.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::GRAPH &val);

  91.   static bool SetValue(proto::AttrDef &attr_def, const vector<int64_t> &val);

  92.   static bool SetValue(proto::AttrDef &attr_def, const vector<int32_t> &val);

  93.   static bool SetValue(proto::AttrDef &attr_def, const vector<uint32_t> &val);

  94.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::LIST_FLOAT &val);

  95.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::LIST_BOOL &val);

  96.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::LIST_STR &val);

  97.   static bool SetValue(proto::AttrDef &proto_attr_val, const vector<GeTensorPtr> &value);

  98.   static bool SetValue(proto::AttrDef &proto_attr_val, const vector<ConstGeTensorPtr> &value);

  99.   static bool SetValue(proto::AttrDef &attr_def, const vector<GeTensor> &val);

  100.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::LIST_TENSOR_DESC &val);

  101.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::LIST_BYTES &val);

  102.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::LIST_NAMED_ATTRS &val);

  103.   static bool SetValue(proto::AttrDef &attr_def, const GeAttrValue::LIST_GRAPH &val);

  104. 

  105.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeAttrValue::INT &val);

  106.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeAttrValue::FLOAT &val);

  107.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeAttrValue::BOOL &val);

  108.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeAttrValue::STR &val);

  109.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeAttrValue::TENSOR &val);

  110.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeTensor &val);

  111.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  112.                        GeAttrValue::TENSOR_DESC &val);

  113.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeAttrValue::BYTES &val);

  114.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  115.                        GeAttrValue::NAMED_ATTRS &val);

  116.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, GeAttrValue::GRAPH &val);

  117.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  118.                        GeAttrValue::LIST_INT &val);

  119.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  120.                        GeAttrValue::LIST_FLOAT &val);

  121.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  122.                        GeAttrValue::LIST_BOOL &val);

  123.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  124.                        GeAttrValue::LIST_STR &val);

  125.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  126.                        GeAttrValue::LIST_TENSOR &val);

  127.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, vector<GeTensor> &val);

  128.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  129.                        GeAttrValue::LIST_TENSOR_DESC &val);

  130.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  131.                        GeAttrValue::LIST_BYTES &val);

  132.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  133.                        GeAttrValue::LIST_NAMED_ATTRS &val);

  134.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  135.                        GeAttrValue::LIST_GRAPH &val);

  136.   // Value will be moved

  137.   static bool SetZeroCopyBytes(proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, Buffer &&buffer);

  138.   static bool GetZeroCopyBytes(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, Buffer &buffer);

  139.   // Value will be moved

  140.   static bool SetZeroCopyListBytes(proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  141.                                    vector<Buffer> &list_buffer);

  142.   static bool GetZeroCopyListBytes(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  143.                                    vector<Buffer> &list_buffer);

  144. 

  145.   static bool SetValue(proto::AttrDef &attr_def, const vector<vector<int64_t>> &value);

  146.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  147.                        vector<vector<int64_t>> &value);

  148.   static bool SetValue(proto::AttrDef &attr_def, const vector<ge::DataType> &value);

  149.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner,

  150.                        vector<ge::DataType> &value);

  151. 

  152.   static bool SetValue(proto::AttrDef &attr_def, const ge::DataType &value);

  153.   static bool GetValue(const proto::AttrDef &attr_def, const ProtoMsgOwner &proto_msg_owner, ge::DataType &value);

  154. };

  155. 

  156. map<proto::AttrDef::ValueCase, GeAttrValue::ValueType> GeAttrValueImp::attr_val_one_type_map_ = {

  157.     {proto::AttrDef::kI, GeAttrValue::VT_INT},

  158.     {proto::AttrDef::kF, GeAttrValue::VT_FLOAT},

  159.     {proto::AttrDef::kB, GeAttrValue::VT_BOOL},

  160.     {proto::AttrDef::kS, GeAttrValue::VT_STRING},

  161.     {proto::AttrDef::kT, GeAttrValue::VT_TENSOR},

  162.     {proto::AttrDef::kTd, GeAttrValue::VT_TENSOR_DESC},

  163.     {proto::AttrDef::kG, GeAttrValue::VT_GRAPH},

  164.     {proto::AttrDef::kBt, GeAttrValue::VT_BYTES},

  165.     {proto::AttrDef::kFunc, GeAttrValue::VT_NAMED_ATTRS},

  166.     {proto::AttrDef::kListListInt, GeAttrValue::VT_LIST_LIST_INT},

  167.     {proto::AttrDef::kDt, GeAttrValue::VT_DATA_TYPE},

  168. };

  169. map<proto::AttrDef_ListValue_ListValueType, GeAttrValue::ValueType> GeAttrValueImp::attr_val_list_type_map_ = {

  170.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_INT, GeAttrValue::VT_LIST_INT},

  171.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_FLOAT, GeAttrValue::VT_LIST_FLOAT},

  172.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_BOOL, GeAttrValue::VT_LIST_BOOL},

  173.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_STRING, GeAttrValue::VT_LIST_STRING},

  174.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_TENSOR, GeAttrValue::VT_LIST_TENSOR},

  175.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_TENSOR_DESC, GeAttrValue::VT_LIST_TENSOR_DESC},

  176.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_GRAPH, GeAttrValue::VT_LIST_GRAPH},

  177.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_BYTES, GeAttrValue::VT_LIST_BYTES},

  178.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_NAMED_ATTRS, GeAttrValue::VT_LIST_NAMED_ATTRS},

  179.     {proto::AttrDef_ListValue_ListValueType_VT_LIST_DATA_TYPE, GeAttrValue::VT_LIST_DATA_TYPE},

  180. };

  181. 

  182. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY GeAttrValue::GeAttrValue() { value_.InitDefault(); }

  183. 

  184. GeAttrValue::GeAttrValue(const ProtoMsgOwner &proto_owner, ge::proto::AttrDef *val) : value_(proto_owner, val) {}

  185. 

  186. GeAttrValue::ValueType GeAttrValue::GetValueType() const {

  187.   auto proto_msg = value_.GetProtoMsg();

  188.   if (proto_msg != nullptr) {

  189.     auto val_case = proto_msg->value_case();

  190.     if (val_case != proto::AttrDef::kList) {

  191.       auto it = GeAttrValueImp::attr_val_one_type_map_.find(val_case);

  192.       if (it != GeAttrValueImp::attr_val_one_type_map_.end()) {

  193.         return it->second;

  194.       }

  195.     } else {

  196.       auto it = GeAttrValueImp::attr_val_list_type_map_.find(proto_msg->list().val_type());

  197.       if (it != GeAttrValueImp::attr_val_list_type_map_.end()) {

  198.         return it->second;

  199.       }

  200.     }

  201.   }

  202.   return GeAttrValue::VT_NONE;

  203. }

  204. 

  205. bool GeAttrValue::IsEmpty() const { return GetValueType() == VT_NONE; }

  206. 

  207. GeAttrValue GeAttrValue::Copy() const {

  208.   GeAttrValue valueRet;

  209.   auto proto_msg = value_.GetProtoMsg();

  210.   auto proto_msg_ret = valueRet.value_.GetProtoMsg();

  211.   if (proto_msg != nullptr && proto_msg_ret != nullptr) {

  212.     *proto_msg_ret = *proto_msg;

  213.   }

  214.   return valueRet;

  215. }

  216. 

  217. #define ATTR_VALUE_SET_GET_IMP(type)                                           \

  218.   graphStatus GeAttrValue::SetValue(const type &val) {                         \

  219.     auto proto_msg = value_.GetProtoMsg();                                     \

  220.     if (proto_msg) {                                                           \

  221.       if (GeAttrValueImp::SetValue(*proto_msg, val)) {                         \

  222.         return GRAPH_SUCCESS;                                                  \

  223.       }                                                                        \

  224.     }                                                                          \

  225.     return GRAPH_FAILED;                                                       \

  226.   }                                                                            \

  227.                                                                                \

  228.   graphStatus GeAttrValue::GetValue(type &val) const {                         \

  229.     auto proto_msg = value_.GetProtoMsg();                                     \

  230.     if (proto_msg) {                                                           \

  231.       if (GeAttrValueImp::GetValue(*proto_msg, value_.GetProtoOwner(), val)) { \

  232.         return GRAPH_SUCCESS;                                                  \

  233.       }                                                                        \

  234.     }                                                                          \

  235.     return GRAPH_FAILED;                                                       \

  236.   }

  237. 

  238. ATTR_VALUE_SET_GET_IMP(GeAttrValue::STR)

  239. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::STR>)

  240. ATTR_VALUE_SET_GET_IMP(GeAttrValue::INT)

  241. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::INT>)

  242. ATTR_VALUE_SET_GET_IMP(GeAttrValue::FLOAT)  // lint !e524

  243. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::FLOAT>)

  244. ATTR_VALUE_SET_GET_IMP(GeAttrValue::BOOL)

  245. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::BOOL>)

  246. ATTR_VALUE_SET_GET_IMP(GeAttrValue::TENSOR_DESC)

  247. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::TENSOR_DESC>)

  248. ATTR_VALUE_SET_GET_IMP(GeAttrValue::TENSOR)

  249. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::TENSOR>)

  250. ATTR_VALUE_SET_GET_IMP(GeAttrValue::GRAPH)

  251. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::GRAPH>)

  252. ATTR_VALUE_SET_GET_IMP(GeAttrValue::BYTES)

  253. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::BYTES>)

  254. ATTR_VALUE_SET_GET_IMP(GeAttrValue::NAMED_ATTRS)

  255. ATTR_VALUE_SET_GET_IMP(vector<GeAttrValue::NAMED_ATTRS>)

  256. /*lint -e665*/

  257. ATTR_VALUE_SET_GET_IMP(vector<vector<int64_t>>)

  258. /*lint +e665*/

  259. ATTR_VALUE_SET_GET_IMP(vector<DataType>)        // lint !e665

  260. ATTR_VALUE_SET_GET_IMP(GeAttrValue::DATA_TYPE)  // lint !e665

  261. 

  262. #undef ATTR_VALUE_SET_GET_IMP

  263. 

  264. graphStatus GeAttrValue::MutableTensor(GeTensorPtr &tensor) { return GetValue(tensor); }

  265. 

  266. graphStatus GeAttrValue::MutableListTensor(vector<GeTensorPtr> &list_tensor) { return GetValue(list_tensor); }

  267. 

  268. class AttrUtilsHelper {

  269.  public:

  270.   inline static bool GetValueCheckType(const proto::AttrDef &attr_def, proto::AttrDef::ValueCase proto_case) {

  271.     if (attr_def.value_case() != proto_case) {

  272.       GELOGW("Check Type Failed, proto case type %u, expected %u", attr_def.value_case(), proto_case);

  273.       return false;

  274.     }

  275.     return true;

  276.   }

  277. 

  278.   inline static bool GetValueCheckListType(

  279.       const proto::AttrDef &attr_def, proto::AttrDef_ListValue_ListValueType proto_list_case,

  280.       const std::function<bool(const proto::AttrDef &proto_attr_val)> item_check_fun) {

  281.     if (attr_def.value_case() != proto::AttrDef::kList) {

  282.       GELOGW("Check ListType Failed, value_case %u", attr_def.value_case());

  283.       return false;

  284.     }

  285.     auto &list = attr_def.list();

  286.     if (list.val_type() == proto::AttrDef_ListValue_ListValueType_VT_LIST_NONE) {

  287.       return item_check_fun(attr_def);

  288.     }

  289.     if (list.val_type() != proto_list_case) {

  290.       GELOGW("Check ListType Failed, val_type %u, expected %u", list.val_type(), proto_list_case);

  291.       return false;

  292.     }

  293.     return true;

  294.   }

  295. 

  296.   inline static bool SetValueCheckType(proto::AttrDef &attr_def, proto::AttrDef::ValueCase proto_case) {

  297.     if (attr_def.value_case() != proto::AttrDef::VALUE_NOT_SET && attr_def.value_case() != proto_case) {

  298.       GELOGW("Check Type Failed, proto case type %u, expected %u", attr_def.value_case(), proto_case);

  299.       return false;

  300.     }

  301.     return true;

  302.   }

  303. 

  304.   inline static bool SetValueCheckAndSetListType(proto::AttrDef &attr_def,

  305.                                                  proto::AttrDef_ListValue_ListValueType proto_list_case) {

  306.     if (attr_def.value_case() != proto::AttrDef::VALUE_NOT_SET && attr_def.value_case() != proto::AttrDef::kList) {

  307.       GELOGW("AttrUtils::Check Type Failed, value_case %u", attr_def.value_case());

  308.       return false;

  309.     }

  310.     auto list = attr_def.mutable_list();

  311.     if (list == nullptr) {

  312.       GELOGE(GRAPH_FAILED, "list is nullptr");

  313.       return false;

  314.     }

  315.     if (list->val_type() != proto::AttrDef_ListValue_ListValueType_VT_LIST_NONE &&

  316.         list->val_type() != proto_list_case) {

  317.       GELOGW("AttrUtils::Check ListType Type Failed, val_type %d, expected %d", static_cast<int>(list->val_type()),

  318.              static_cast<int>(proto_list_case));

  319.       return false;

  320.     }

  321.     list->set_val_type(proto_list_case);

  322.     return true;

  323.   }

  324. 

  325.   static bool GetAttrMapItem(const AttrHolder *obj, const string &name, const proto::AttrDef *&attr_def) {

  326.     if (obj == nullptr) {

  327.       GELOGE(FAILED, "%s obj is nullptr", name.c_str());

  328.       return false;

  329.     }

  330.     auto attr_map = obj->GetAttrMap().GetProtoMsg();

  331.     if (attr_map == nullptr) {

  332.       GELOGE(FAILED, "%s attr map is nullptr", name.c_str());

  333.       return false;

  334.     }

  335.     auto it = attr_map->find(name);

  336.     if (it == attr_map->end()) {

  337.       return false;

  338.     }

  339.     attr_def = &it->second;

  340.     return true;

  341.   }

  342. 

  343.   inline static bool MutableAttrMapItem(AttrHolder *obj, const string &name, proto::AttrDef *&attr_def) {

  344.     if (obj == nullptr) {

  345.       GELOGE(FAILED, " %s obj is nullptr", name.c_str());

  346.       return false;

  347.     }

  348.     auto attr_map = obj->MutableAttrMap().GetProtoMsg();

  349.     if (attr_map == nullptr) {

  350.       GELOGE(FAILED, "%s attr map is nullptr", name.c_str());

  351.       return false;

  352.     }

  353.     // Get or add

  354.     attr_def = &((*attr_map)[name]);

  355.     return true;

  356.   }

  357. };

  358. 

  359. #define ATTR_VALUE_IMP_SET_ONE(ValType, proto_case, protoItem)                             \

  360.   bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, ValType value) {           \

  361.     if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::proto_case)) { \

  362.       return false;                                                                        \

  363.     }                                                                                      \

  364.     proto_attr_val.set_##protoItem(value);                                                 \

  365.     return true;                                                                           \

  366.   }

  367. 

  368. #define ATTR_VALUE_IMP_SET_LIST(ValType, proto_list_case, protoItem)                                               \

  369.   bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, ValType value) {                                   \

  370.     if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,                                              \

  371.                                                       proto::AttrDef_ListValue_ListValueType_##proto_list_case)) { \

  372.       return false;                                                                                                \

  373.     }                                                                                                              \

  374.     auto list = proto_attr_val.mutable_list();                                                                     \

  375.     list->clear_##protoItem();                                                                                     \

  376.     for (const auto &item : value) {                                                                               \

  377.       list->add_##protoItem(item);                                                                                 \

  378.     }                                                                                                              \

  379.     return true;                                                                                                   \

  380.   }

  381. 

  382. ATTR_VALUE_IMP_SET_ONE(int64_t, kI, i)

  383. ATTR_VALUE_IMP_SET_ONE(float, kF, f)

  384. ATTR_VALUE_IMP_SET_ONE(const string &, kS, s)

  385. ATTR_VALUE_IMP_SET_ONE(bool, kB, b)

  386. 

  387. ATTR_VALUE_IMP_SET_LIST(const vector<int64_t> &, VT_LIST_INT, i)

  388. ATTR_VALUE_IMP_SET_LIST(const vector<int32_t> &, VT_LIST_INT, i)

  389. ATTR_VALUE_IMP_SET_LIST(const vector<uint32_t> &, VT_LIST_INT, i)

  390. ATTR_VALUE_IMP_SET_LIST(const vector<float> &, VT_LIST_FLOAT, f)

  391. ATTR_VALUE_IMP_SET_LIST(const vector<string> &, VT_LIST_STRING, s)

  392. ATTR_VALUE_IMP_SET_LIST(const vector<bool> &, VT_LIST_BOOL, b)

  393. 

  394. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const GeTensorDesc &value) {

  395.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kTd)) {

  396.     return false;

  397.   }

  398.   auto proto_msg = value.tensor_descriptor_.GetProtoMsg();

  399.   if (proto_msg == nullptr) {

  400.     return false;

  401.   }

  402.   *proto_attr_val.mutable_td() = *proto_msg;

  403.   return true;

  404. }

  405. 

  406. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<GeTensorDesc> &value) {

  407.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  408.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_TENSOR_DESC)) {

  409.     return false;

  410.   }

  411.   auto list = proto_attr_val.mutable_list();

  412.   GE_CHECK_NOTNULL_EXEC(list, return false);

  413.   list->clear_td();

  414.   for (const auto &item : value) {

  415.     auto proto_msg = item.tensor_descriptor_.GetProtoMsg();

  416.     if (proto_msg == nullptr) {

  417.       proto_attr_val.clear_list();

  418.       return false;

  419.     }

  420.     *list->add_td() = *proto_msg;

  421.   }

  422.   return true;

  423. }

  424. 

  425. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const ConstGeTensorPtr &value) {

  426.   if (value) {

  427.     return SetValue(proto_attr_val, *value);

  428.   } else {

  429.     return SetValue(proto_attr_val, GeTensor());

  430.   }

  431. }

  432. 

  433. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const GeTensor &val) {

  434.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kT)) {

  435.     return false;

  436.   }

  437.   auto proto_msg = val.tensor_def_.GetProtoMsg();

  438.   if (proto_msg == nullptr) {

  439.     GELOGE(FAILED, "Proto msg is nullptr");

  440.     return false;

  441.   }

  442.   *proto_attr_val.mutable_t() = *proto_msg;

  443.   return true;

  444. }

  445. 

  446. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<GeTensorPtr> &value) {

  447.   vector<ConstGeTensorPtr> constList(value.size());

  448.   std::copy(value.begin(), value.end(), constList.begin());

  449.   return SetValue(proto_attr_val, constList);

  450. }

  451. 

  452. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<ConstGeTensorPtr> &value) {

  453.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  454.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_TENSOR)) {

  455.     return false;

  456.   }

  457.   auto list = proto_attr_val.mutable_list();

  458.   GE_CHECK_NOTNULL_EXEC(list, return false);

  459.   list->clear_t();

  460.   for (const auto &item : value) {

  461.     if (item == nullptr) {

  462.       GELOGE(GRAPH_FAILED, "AttrUtils::SetListTensor item is nullptr");

  463.       proto_attr_val.clear_list();

  464.       return false;

  465.     }

  466.     auto proto_msg = item->tensor_def_.GetProtoMsg();

  467.     if (proto_msg == nullptr) {

  468.       GELOGE(FAILED, "Proto msg is nullptr");

  469.       proto_attr_val.clear_list();

  470.       return false;

  471.     }

  472.     *list->add_t() = *proto_msg;

  473.   }

  474.   return true;

  475. }

  476. 

  477. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<GeTensor> &value) {

  478.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  479.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_TENSOR)) {

  480.     return false;

  481.   }

  482.   auto list = proto_attr_val.mutable_list();

  483.   GE_CHECK_NOTNULL_EXEC(list, return false);

  484.   list->clear_t();

  485.   for (const auto &item : value) {

  486.     auto proto_msg = item.tensor_def_.GetProtoMsg();

  487.     if (proto_msg == nullptr) {

  488.       GELOGE(FAILED, "Proto msg is nullptr");

  489.       proto_attr_val.clear_list();

  490.       return false;

  491.     }

  492.     *list->add_t() = *proto_msg;

  493.   }

  494.   return true;

  495. }

  496. 

  497. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const GeAttrValue::BYTES &value) {

  498.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kBt)) {

  499.     return false;

  500.   }

  501.   size_t val_size = value.GetSize();

  502.   proto_attr_val.set_bt(value.GetData(), val_size);

  503.   return true;

  504. }

  505. 

  506. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<GeAttrValue::BYTES> &value) {

  507.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  508.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_BYTES)) {

  509.     return false;

  510.   }

  511.   auto list = proto_attr_val.mutable_list();

  512.   GE_CHECK_NOTNULL_EXEC(list, return false);

  513.   list->clear_bt();

  514.   for (const auto &item : value) {

  515.     list->add_bt(item.GetData(), item.GetSize());

  516.   }

  517.   return true;

  518. }

  519. 

  520. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const GeAttrValue::NAMED_ATTRS &value) {

  521.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kFunc)) {

  522.     return false;

  523.   }

  524.   auto proto_msg = value.named_attrs_.GetProtoMsg();

  525.   if (proto_msg == nullptr) {

  526.     GELOGE(FAILED, "Proto msg is nullptr");

  527.     return false;

  528.   }

  529.   *proto_attr_val.mutable_func() = *proto_msg;

  530.   return true;

  531. }

  532. 

  533. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<GeAttrValue::NAMED_ATTRS> &value) {

  534.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  535.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_NAMED_ATTRS)) {

  536.     return false;

  537.   }

  538.   auto list = proto_attr_val.mutable_list();

  539.   GE_CHECK_NOTNULL_EXEC(list, return false);

  540.   list->clear_na();

  541.   for (const auto &item : value) {

  542.     auto proto_msg = item.named_attrs_.GetProtoMsg();

  543.     if (proto_msg == nullptr) {

  544.       proto_attr_val.clear_list();

  545.       return false;

  546.     }

  547.     *list->add_na() = *proto_msg;

  548.   }

  549.   return true;

  550. }

  551. 

  552. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const ge::ComputeGraphPtr &value) {

  553.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kG)) {

  554.     return false;

  555.   }

  556.   ModelSerializeImp imp;

  557.   if (!imp.SerializeGraph(value, proto_attr_val.mutable_g())) {

  558.     GELOGE(GRAPH_FAILED, "AttrUtils::SetGraph SerializeGraph Failed");

  559.     proto_attr_val.clear_g();

  560.     return false;

  561.   }

  562.   return true;

  563. }

  564. 

  565. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<ge::ComputeGraphPtr> &value) {

  566.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  567.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_GRAPH)) {

  568.     return false;

  569.   }

  570.   auto list = proto_attr_val.mutable_list();

  571.   GE_CHECK_NOTNULL_EXEC(list, return false);

  572.   list->clear_g();

  573. 

  574.   ModelSerializeImp imp;

  575.   for (const auto &item : value) {

  576.     if (!imp.SerializeGraph(item, list->add_g())) {

  577.       GELOGE(GRAPH_FAILED, "AttrUtils::SetListGraph SerializeGraph");

  578.       proto_attr_val.clear_list();

  579.       return false;

  580.     }

  581.   }

  582.   return true;

  583. }

  584. 

  585. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<vector<int64_t>> &value) {

  586.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kListListInt)) {

  587.     return false;

  588.   }

  589.   proto_attr_val.clear_list_list_int();

  590.   auto list_list_int = proto_attr_val.mutable_list_list_int();

  591.   GE_CHECK_NOTNULL_EXEC(list_list_int, return false);

  592.   for (auto &list_int : value) {

  593.     auto list_item = list_list_int->add_list_list_i();

  594.     GE_CHECK_NOTNULL_EXEC(list_item, return false);

  595.     for (auto &int_item : list_int) {

  596.       list_item->add_list_i(int_item);

  597.     }

  598.   }

  599.   return true;

  600. }

  601. 

  602. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const vector<ge::DataType> &value) {

  603.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  604.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_DATA_TYPE)) {

  605.     return false;

  606.   }

  607.   auto list = proto_attr_val.mutable_list();

  608.   GE_CHECK_NOTNULL_EXEC(list, return false);

  609.   list->clear_dt();

  610.   for (const auto &item : value) {

  611.     list->add_dt(static_cast<int64_t>(item));

  612.   }

  613.   return true;

  614. }

  615. 

  616. bool GeAttrValueImp::SetValue(proto::AttrDef &proto_attr_val, const ge::DataType &value) {

  617.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kDt)) {

  618.     return false;

  619.   }

  620.   proto_attr_val.set_dt(static_cast<int64_t>(value));

  621. 

  622.   return true;

  623. }

  624. 

  625. #define ATTR_VALUE_IMP_GET_ONE(ValType, proto_case, protoItem)                                                \

  626.   bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &, ValType value) { \

  627.     if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::proto_case)) {                    \

  628.       return false;                                                                                           \

  629.     }                                                                                                         \

  630.     value = proto_attr_val.protoItem();                                                                       \

  631.     return true;                                                                                              \

  632.   }

  633. 

  634. #define ListValueItemCheck(protoItem) \

  635.   [](const proto::AttrDef &proto_attr_val) { return proto_attr_val.list().protoItem##_size() > 0; }

  636. 

  637. #define ATTR_VALUE_IMP_GET_LIST(ValType, proto_list_case, protoItem)                                                   \

  638.   bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &, vector<ValType> &value) { \

  639.     value.clear();                                                                                                     \

  640.     if (!AttrUtilsHelper::GetValueCheckListType(proto_attr_val,                                                        \

  641.                                                 proto::AttrDef_ListValue_ListValueType_##proto_list_case,              \

  642.                                                 ListValueItemCheck(protoItem))) {                                      \

  643.       return false;                                                                                                    \

  644.     }                                                                                                                  \

  645.     auto &list = proto_attr_val.list();                                                                                \

  646.     for (const auto &item : list.protoItem()) {                                                                        \

  647.       value.push_back(item);                                                                                           \

  648.     }                                                                                                                  \

  649.     return true;                                                                                                       \

  650.   }

  651. 

  652. ATTR_VALUE_IMP_GET_ONE(int64_t &, kI, i)

  653. ATTR_VALUE_IMP_GET_ONE(float &, kF, f)

  654. ATTR_VALUE_IMP_GET_ONE(string &, kS, s)

  655. ATTR_VALUE_IMP_GET_ONE(bool &, kB, b)

  656. 

  657. ATTR_VALUE_IMP_GET_LIST(int64_t, VT_LIST_INT, i)

  658. ATTR_VALUE_IMP_GET_LIST(float, VT_LIST_FLOAT, f)

  659. ATTR_VALUE_IMP_GET_LIST(string, VT_LIST_STRING, s)

  660. ATTR_VALUE_IMP_GET_LIST(bool, VT_LIST_BOOL, b)

  661. 

  662. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &, GeTensorDesc &value) {

  663.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kTd)) {

  664.     return false;

  665.   }

  666.   auto proto_msg = value.tensor_descriptor_.GetProtoMsg();

  667.   if (proto_msg == nullptr) {

  668.     return false;

  669.   }

  670.   *proto_msg = proto_attr_val.td();

  671.   return true;

  672. }

  673. 

  674. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  675.                               vector<GeTensorDesc> &value) {

  676.   if (!AttrUtilsHelper::GetValueCheckListType(

  677.           proto_attr_val, proto::AttrDef_ListValue_ListValueType_VT_LIST_TENSOR_DESC, ListValueItemCheck(td))) {

  678.     return false;

  679.   }

  680.   auto &list = proto_attr_val.list();

  681.   for (const auto &item : list.td()) {

  682.     value.emplace_back(GeTensorDesc());

  683.     auto proto_msg = value.back().tensor_descriptor_.GetProtoMsg();

  684.     if (proto_msg == nullptr) {

  685.       return false;

  686.     }

  687.     *proto_msg = item;

  688.   }

  689.   return true;

  690. }

  691. 

  692. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &proto_owner,

  693.                               GeTensorPtr &value) {

  694.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kT)) {

  695.     return false;

  696.   }

  697.   value = std::shared_ptr<GeTensor>(

  698.       new (std::nothrow) GeTensor(proto_owner, const_cast<proto::AttrDef &>(proto_attr_val).mutable_t()));

  699.   GE_CHK_BOOL_RET_STATUS(value != nullptr, false, "value is nullptr");

  700.   return true;

  701. }

  702. 

  703. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &proto_owner,

  704.                               vector<GeTensorPtr> &value) {

  705.   value.clear();

  706.   if (!AttrUtilsHelper::GetValueCheckListType(proto_attr_val, proto::AttrDef_ListValue_ListValueType_VT_LIST_TENSOR,

  707.                                               ListValueItemCheck(t))) {

  708.     return false;

  709.   }

  710.   auto list = const_cast<proto::AttrDef &>(proto_attr_val).mutable_list();

  711.   GE_CHECK_NOTNULL_EXEC(list, return false);

  712.   for (auto &item : *(list->mutable_t())) {

  713.     std::shared_ptr<GeTensor> temp_value = std::shared_ptr<GeTensor>(new (std::nothrow) GeTensor(proto_owner, &item));

  714.     GE_CHK_BOOL_RET_STATUS(temp_value != nullptr, false, "temp_value is nullptr");

  715.     value.push_back(temp_value);

  716.   }

  717.   return true;

  718. }

  719. 

  720. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &, GeAttrValue::BYTES &value) {

  721.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kBt)) {

  722.     return false;

  723.   }

  724.   auto &proto_val = proto_attr_val.bt();

  725.   GE_LOGI_IF(proto_val.size() == 0, "size res is 0.");

  726.   value = Buffer::CopyFrom(reinterpret_cast<const uint8_t *>(proto_val.data()), proto_val.size());

  727.   return true;

  728. }

  729. 

  730. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  731.                               vector<GeAttrValue::BYTES> &value) {

  732.   value.clear();

  733.   if (!AttrUtilsHelper::GetValueCheckListType(proto_attr_val, proto::AttrDef_ListValue_ListValueType_VT_LIST_BYTES,

  734.                                               ListValueItemCheck(bt))) {

  735.     return false;

  736.   }

  737.   auto &list = proto_attr_val.list();

  738.   for (const auto &item : list.bt()) {

  739.     value.push_back(Buffer::CopyFrom((const uint8_t *)item.data(), item.size()));

  740.   }

  741.   return true;

  742. }

  743. 

  744. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  745.                               GeAttrValue::NAMED_ATTRS &value) {

  746.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kFunc)) {

  747.     return false;

  748.   }

  749.   auto proto_msg = value.named_attrs_.GetProtoMsg();

  750.   if (proto_msg == nullptr) {

  751.     return false;

  752.   }

  753.   *proto_msg = proto_attr_val.func();

  754.   return true;

  755. }

  756. 

  757. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  758.                               vector<GeAttrValue::NAMED_ATTRS> &value) {

  759.   value.clear();

  760.   if (!AttrUtilsHelper::GetValueCheckListType(

  761.           proto_attr_val, proto::AttrDef_ListValue_ListValueType_VT_LIST_NAMED_ATTRS, ListValueItemCheck(na))) {

  762.     return false;

  763.   }

  764.   auto &list = proto_attr_val.list();

  765.   for (const auto &item : list.na()) {

  766.     value.emplace_back(GeAttrValue::NAMED_ATTRS());

  767.     if (value.empty()) {

  768.       return false;

  769.     }

  770.     auto proto_msg = value.back().named_attrs_.GetProtoMsg();

  771.     if (proto_msg == nullptr) {

  772.       return false;

  773.     }

  774.     *proto_msg = item;

  775.   }

  776.   return true;

  777. }

  778. 

  779. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &, ComputeGraphPtr &value) {

  780.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kG)) {

  781.     return false;

  782.   }

  783.   ComputeGraphPtr graph = nullptr;

  784.   std::shared_ptr<proto::GraphDef> graph_def;

  785.   graph_def = ComGraphMakeShared<proto::GraphDef>(proto_attr_val.g());

  786.   if (graph_def == nullptr) {

  787.     GELOGE(GRAPH_FAILED, "proto::GraphDef make shared failed");

  788.     graph_def = nullptr;

  789.     return false;  // lint !e665

  790.   } else {

  791.     ModelSerializeImp imp;

  792.     imp.SetProtobufOwner(graph_def);

  793.     if (!imp.UnserializeGraph(graph, *graph_def)) {

  794.       GELOGE(GRAPH_FAILED, "UnserializeGraph Failed");

  795.       return false;

  796.     }  // lint !e514

  797.     value = graph;

  798.   }

  799.   return true;

  800. }

  801. 

  802. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  803.                               vector<ComputeGraphPtr> &value) {

  804.   value.clear();

  805.   if (!AttrUtilsHelper::GetValueCheckListType(proto_attr_val, proto::AttrDef_ListValue_ListValueType_VT_LIST_GRAPH,

  806.                                               ListValueItemCheck(g))) {

  807.     return false;

  808.   }

  809.   auto &list = proto_attr_val.list();

  810.   for (const auto &item : list.g()) {

  811.     std::shared_ptr<proto::GraphDef> graph_def;

  812.     graph_def = ComGraphMakeShared<proto::GraphDef>(item);

  813.     if (graph_def == nullptr) {

  814.       GELOGE(GRAPH_FAILED, "proto::GraphDef make shared failed");

  815.       graph_def = nullptr;

  816.       return false;  // lint !e665

  817.     } else {

  818.       ComputeGraphPtr graph = nullptr;

  819.       ModelSerializeImp imp;

  820.       imp.SetProtobufOwner(graph_def);

  821.       if (!imp.UnserializeGraph(graph, *graph_def)) {

  822.         GELOGE(GRAPH_FAILED, "UnserializeGraph Failed");

  823.         return false;

  824.       }  // lint !e514

  825.       value.push_back(graph);

  826.     }

  827.   }

  828.   return true;

  829. }

  830. 

  831. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  832.                               vector<vector<int64_t>> &value) {

  833.   value.clear();

  834.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kListListInt)) {

  835.     return false;

  836.   }

  837. 

  838.   auto &list_listint = proto_attr_val.list_list_int().list_list_i();

  839.   for (auto &list_int : list_listint) {

  840.     vector<int64_t> list_item(list_int.list_i().size());

  841.     if (!list_int.list_i().empty()) {

  842.       (void)std::copy(list_int.list_i().begin(), list_int.list_i().end(), list_item.begin());

  843.     }

  844.     value.push_back(list_item);

  845.   }

  846.   return true;

  847. }

  848. 

  849. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  850.                               vector<ge::DataType> &value) {

  851.   if (!AttrUtilsHelper::GetValueCheckListType(proto_attr_val, proto::AttrDef_ListValue_ListValueType_VT_LIST_DATA_TYPE,

  852.                                               ListValueItemCheck(dt))) {

  853.     return false;

  854.   }

  855.   auto &list = proto_attr_val.list();

  856.   for (const auto &item : list.dt()) {

  857.     value.emplace_back(static_cast<ge::DataType>(item));

  858.   }

  859.   return true;

  860. }

  861. 

  862. bool GeAttrValueImp::GetValue(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &, ge::DataType &value) {

  863.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kDt)) {

  864.     return false;

  865.   }

  866.   value = static_cast<ge::DataType>(proto_attr_val.dt());

  867.   return true;

  868. }

  869. 

  870. GE_FUNC_HOST_VISIBILITY bool GeAttrValueImp::SetZeroCopyBytes(proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  871.                                                               Buffer &&buffer) {

  872.   if (!AttrUtilsHelper::SetValueCheckType(proto_attr_val, proto::AttrDef::kBt)) {

  873.     return false;

  874.   }

  875.   auto proto_msg = buffer.data_.GetProtoMsg();

  876.   if (proto_msg == nullptr) {

  877.     return false;

  878.   }

  879.   proto_attr_val.set_bt(std::move(*proto_msg->mutable_bt()));

  880.   return true;

  881. }

  882. 

  883. bool GeAttrValueImp::GetZeroCopyBytes(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &proto_owner,

  884.                                       Buffer &buffer) {

  885.   if (!AttrUtilsHelper::GetValueCheckType(proto_attr_val, proto::AttrDef::kBt)) {

  886.     return false;

  887.   }

  888.   buffer = Buffer(proto_owner, &const_cast<proto::AttrDef &>(proto_attr_val));

  889.   return true;

  890. }

  891. 

  892. bool GeAttrValueImp::SetZeroCopyListBytes(proto::AttrDef &proto_attr_val, const ProtoMsgOwner &,

  893.                                           vector<Buffer> &list_buffer) {

  894.   if (!AttrUtilsHelper::SetValueCheckAndSetListType(proto_attr_val,

  895.                                                     proto::AttrDef_ListValue_ListValueType_VT_LIST_BYTES)) {

  896.     return false;

  897.   }

  898.   auto list = proto_attr_val.mutable_list();

  899.   GE_CHECK_NOTNULL_EXEC(list, return false);

  900.   list->clear_bt();

  901.   for (auto &item : list_buffer) {

  902.     auto proto_msg = item.data_.GetProtoMsg();

  903.     if (proto_msg == nullptr) {

  904.       return false;

  905.     }

  906.     list->add_bt(std::move(*proto_msg->mutable_bt()));

  907.   }

  908.   return true;

  909. }

  910. 

  911. bool GeAttrValueImp::GetZeroCopyListBytes(const proto::AttrDef &proto_attr_val, const ProtoMsgOwner &proto_owner,

  912.                                           vector<Buffer> &list_buffer) {

  913.   list_buffer.clear();

  914.   if (!AttrUtilsHelper::GetValueCheckListType(proto_attr_val, proto::AttrDef_ListValue_ListValueType_VT_LIST_BYTES,

  915.                                               ListValueItemCheck(bt))) {

  916.     return false;

  917.   }

  918.   auto list = const_cast<proto::AttrDef &>(proto_attr_val).mutable_list();

  919.   GE_CHECK_NOTNULL_EXEC(list, return false);

  920.   for (auto &item : *(list->mutable_bt())) {

  921.     list_buffer.emplace_back(Buffer(proto_owner, &item));

  922.   }

  923.   return true;

  924. }

  925. 

  926. bool AttrUtils::HasAttr(ConstAttrHolderAdapter &&obj, const string &name) {

  927.   if (!obj) {

  928.     return false;

  929.   }

  930.   return obj->HasAttr(name);

  931. }

  932. 

  933. #define ATTR_UTILS_SET_IMP(FuncName, Type)                                                                    \

  934.   GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::Set##FuncName(                               \

  935.       AttrHolderAdapter &&obj, const string &name, const Type &value) {                                       \

  936.     proto::AttrDef *proto_attr_val = nullptr;                                                                 \

  937.     if (!AttrUtilsHelper::MutableAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) { \

  938.       return false;                                                                                           \

  939.     }                                                                                                         \

  940.     if (!GeAttrValueImp::SetValue(*proto_attr_val, value)) {                                                  \

  941.       GELOGW("Set" #FuncName " failed key %s", name.c_str());                                                 \

  942.       return false;                                                                                           \

  943.     }                                                                                                         \

  944.     return true;                                                                                              \

  945.   }

  946. 

  947. #define ATTR_UTILS_GET_IMP(FuncName, Type)                                                                        \

  948.   GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::Get##FuncName(ConstAttrHolderAdapter &&obj,      \

  949.                                                                                const string &name, Type &value) { \

  950.     const proto::AttrDef *proto_attr_val = nullptr;                                                               \

  951.     if (!AttrUtilsHelper::GetAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {         \

  952.       return false;                                                                                               \

  953.     }                                                                                                             \

  954.     if (!GeAttrValueImp::GetValue(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), value)) {                   \

  955.       GELOGW("Get" #FuncName " failed key %s", name.c_str());                                                     \

  956.       return false;                                                                                               \

  957.     }                                                                                                             \

  958.     return true;                                                                                                  \

  959.   }

  960. 

  961. #define ATTR_UTILS_SET_GET_IMP(FuncName, Type) \

  962.   ATTR_UTILS_SET_IMP(FuncName, Type)           \

  963.   ATTR_UTILS_GET_IMP(FuncName, Type)

  964. 

  965. ATTR_UTILS_SET_GET_IMP(Int, int64_t)

  966. ATTR_UTILS_SET_GET_IMP(Float, float)

  967. ATTR_UTILS_SET_GET_IMP(Bool, bool)

  968. ATTR_UTILS_SET_GET_IMP(Str, string)

  969. ATTR_UTILS_SET_GET_IMP(TensorDesc, GeTensorDesc)

  970. ATTR_UTILS_SET_IMP(Tensor, GeTensorPtr)

  971. ATTR_UTILS_SET_IMP(Tensor, ConstGeTensorPtr)

  972. ATTR_UTILS_SET_IMP(Tensor, GeTensor)

  973. ATTR_UTILS_SET_GET_IMP(NamedAttrs, GeAttrValue::NAMED_ATTRS)

  974. ATTR_UTILS_SET_GET_IMP(Bytes, Buffer)

  975. ATTR_UTILS_SET_GET_IMP(Graph, ComputeGraphPtr)

  976. /*lint -e665*/

  977. ATTR_UTILS_SET_GET_IMP(ListListInt, vector<vector<int64_t>>)

  978. /*lint +e665*/

  979. ATTR_UTILS_SET_GET_IMP(ListInt, vector<int64_t>)

  980. ATTR_UTILS_SET_IMP(ListInt, vector<int32_t>)

  981. ATTR_UTILS_SET_IMP(ListInt, vector<uint32_t>)

  982. ATTR_UTILS_SET_GET_IMP(ListFloat, vector<float>)

  983. ATTR_UTILS_SET_GET_IMP(ListBool, vector<bool>)

  984. ATTR_UTILS_SET_GET_IMP(ListStr, vector<string>)

  985. ATTR_UTILS_SET_GET_IMP(ListTensorDesc, vector<GeTensorDesc>)

  986. ATTR_UTILS_SET_IMP(ListTensor, vector<GeTensorPtr>)

  987. ATTR_UTILS_SET_IMP(ListTensor, vector<ConstGeTensorPtr>)

  988. ATTR_UTILS_SET_IMP(ListTensor, vector<GeTensor>)

  989. ATTR_UTILS_SET_GET_IMP(ListNamedAttrs, vector<GeAttrValue::NAMED_ATTRS>)

  990. ATTR_UTILS_SET_GET_IMP(ListBytes, vector<Buffer>)

  991. ATTR_UTILS_SET_GET_IMP(ListGraph, vector<ComputeGraphPtr>)

  992. ATTR_UTILS_SET_GET_IMP(ListDataType, vector<ge::DataType>)  // lint !e665

  993. ATTR_UTILS_SET_GET_IMP(DataType, ge::DataType)              // lint !e665

  994. 

  995. bool AttrUtils::SetListTensor(AttrHolderAdapter &&obj, const string &name,

  996.                               std::initializer_list<ConstGeTensorPtr> &&value) {

  997.   return SetListTensor(std::move(obj), name, vector<ConstGeTensorPtr>(value));

  998. }

  999. 

  1000. bool AttrUtils::GetTensor(ConstAttrHolderAdapter &&obj, const string &name, ConstGeTensorPtr &value) {

  1001.   const proto::AttrDef *proto_attr_val = nullptr;

  1002.   if (!AttrUtilsHelper::GetAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1003.     return false;

  1004.   }

  1005.   GeTensorPtr tensor;

  1006.   if (!GeAttrValueImp::GetValue(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), tensor)) {

  1007.     return false;

  1008.   }

  1009.   value = tensor;

  1010.   return true;

  1011. }

  1012. 

  1013. bool AttrUtils::GetListTensor(ConstAttrHolderAdapter &&obj, const string &name, vector<ConstGeTensorPtr> &value) {

  1014.   value.clear();

  1015.   const proto::AttrDef *proto_attr_val = nullptr;

  1016.   if (!AttrUtilsHelper::GetAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1017.     return false;

  1018.   }

  1019.   vector<GeTensorPtr> tensor;

  1020.   if (!GeAttrValueImp::GetValue(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), tensor)) {

  1021.     return false;

  1022.   }

  1023.   value.insert(value.begin(), tensor.begin(), tensor.end());

  1024.   return true;

  1025. }

  1026. 

  1027. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::MutableTensor(AttrHolderAdapter &&obj,

  1028.                                                                              const string &name, GeTensorPtr &value) {

  1029.   const proto::AttrDef *proto_attr_val = nullptr;

  1030.   if (!AttrUtilsHelper::GetAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1031.     return false;

  1032.   }

  1033.   return GeAttrValueImp::GetValue(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), value);

  1034. }

  1035. 

  1036. bool AttrUtils::MutableListTensor(AttrHolderAdapter &&obj, const string &name, vector<GeTensorPtr> &value) {

  1037.   value.clear();

  1038.   const proto::AttrDef *proto_attr_val = nullptr;

  1039.   if (!AttrUtilsHelper::GetAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1040.     return false;

  1041.   }

  1042.   return GeAttrValueImp::GetValue(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), value);

  1043. }

  1044. 

  1045. bool AttrUtils::SetListInt(AttrHolderAdapter &&obj, const string &name, std::initializer_list<int64_t> &&value) {

  1046.   proto::AttrDef *proto_attr_val = nullptr;

  1047.   if (!AttrUtilsHelper::MutableAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1048.     return false;

  1049.   }

  1050.   return GeAttrValueImp::SetValue(*proto_attr_val, value);

  1051. }

  1052. 

  1053. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::GetInt(ConstAttrHolderAdapter &&obj, const string &name,

  1054.                                                                       int32_t &value) {

  1055.   int64_t int64_val = 0;

  1056.   if (!AttrUtils::GetInt(std::move(obj), name, int64_val)) {

  1057.     return false;

  1058.   }

  1059.   if (int64_val > INT32_MAX) {

  1060.     GELOGE(GRAPH_FAILED, "%ld int64_t value cannot cast to int32_t", int64_val);

  1061.     return false;

  1062.   }

  1063.   value = static_cast<int32_t>(int64_val);

  1064.   return true;

  1065. }

  1066. 

  1067. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::GetInt(ConstAttrHolderAdapter &&obj, const string &name,

  1068.                                                                       uint32_t &value) {

  1069.   int64_t int64_val = 0;

  1070.   if (!AttrUtils::GetInt(std::move(obj), name, int64_val)) {

  1071.     return false;

  1072.   }

  1073.   if (int64_val > UINT32_MAX) {

  1074.     GELOGE(GRAPH_FAILED, "%ld int64_t value cannot cast to uint32_t", int64_val);

  1075.     return false;

  1076.   }

  1077.   value = static_cast<uint32_t>(int64_val);

  1078.   return true;

  1079. }

  1080. 

  1081. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::GetListInt(ConstAttrHolderAdapter &&obj,

  1082.                                                                           const string &name, vector<int32_t> &value) {

  1083.   value.clear();

  1084.   vector<int64_t> int64_list;

  1085.   if (!GetListInt(std::move(obj), name, int64_list)) {

  1086.     return false;

  1087.   }

  1088. 

  1089.   for (size_t i = 0; i < int64_list.size(); ++i) {

  1090.     if (int64_list[i] > INT32_MAX) {

  1091.       GELOGE(GRAPH_FAILED, "index %zu %ld int64_t value cannot cast to int32_t", i, int64_list[i]);

  1092.       return false;

  1093.     }

  1094.   }

  1095.   value.insert(value.begin(), int64_list.begin(), int64_list.end());

  1096.   return true;

  1097. }

  1098. 

  1099. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::GetListInt(ConstAttrHolderAdapter &&obj,

  1100.                                                                           const string &name, vector<uint32_t> &value) {

  1101.   value.clear();

  1102.   vector<int64_t> int64_list;

  1103.   if (!GetListInt(std::move(obj), name, int64_list)) {

  1104.     return false;

  1105.   }

  1106. 

  1107.   for (size_t i = 0; i < int64_list.size(); ++i) {

  1108.     if (int64_list[i] > UINT32_MAX) {

  1109.       GELOGE(GRAPH_FAILED, "index %zu %ld int64_t value cannot cast to uint32_t", i, int64_list[i]);

  1110.       return false;

  1111.     }

  1112.   }

  1113.   value.insert(value.begin(), int64_list.begin(), int64_list.end());

  1114.   return true;

  1115. }

  1116. 

  1117. bool AttrUtils::SetListOpDesc(AttrHolderAdapter &&obj, const string &name, const vector<ConstOpDescPtr> &value) {

  1118.   if (obj) {

  1119.     vector<Buffer> bytes_vals;

  1120.     for (auto &item : value) {

  1121.       ModelSerialize serialize;

  1122.       auto buffer = serialize.SerializeOpDesc(item);

  1123.       if (buffer.GetSize() == 0) {

  1124.         return false;

  1125.       }

  1126.       bytes_vals.push_back(buffer);

  1127.     }

  1128.     return SetZeroCopyListBytes(std::move(obj), name, bytes_vals);

  1129.   }

  1130.   return false;

  1131. }

  1132. 

  1133. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::SetListOpDesc(AttrHolderAdapter &&obj,

  1134.                                                                              const string &name,

  1135.                                                                              const vector<OpDescPtr> &value) {

  1136.   if (obj) {

  1137.     vector<Buffer> bytes_vals;

  1138.     for (auto &item : value) {

  1139.       ModelSerialize serialize;

  1140.       auto buffer = serialize.SerializeOpDesc(item);

  1141.       if (buffer.GetSize() == 0) {

  1142.         return false;

  1143.       }

  1144.       bytes_vals.push_back(buffer);

  1145.     }

  1146.     return SetZeroCopyListBytes(std::move(obj), name, bytes_vals);

  1147.   }

  1148.   return false;

  1149. }

  1150. 

  1151. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::GetListOpDesc(ConstAttrHolderAdapter &&obj,

  1152.                                                                              const string &name,

  1153.                                                                              vector<OpDescPtr> &value) {

  1154.   value.clear();

  1155. 

  1156.   vector<Buffer> bytes_vals;

  1157.   if (!GetZeroCopyListBytes(std::move(obj), name, bytes_vals)) {

  1158.     return false;

  1159.   }

  1160.   for (const auto &item : bytes_vals) {

  1161.     ModelSerialize serialize;

  1162.     auto op_desc = serialize.UnserializeOpDesc(item.GetData(), item.GetSize());  // lint !e732

  1163.     value.push_back(op_desc);

  1164.   }

  1165.   return true;

  1166. }

  1167. 

  1168. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::SetZeroCopyBytes(AttrHolderAdapter &&obj,

  1169.                                                                                 const string &name, Buffer &&buffer) {

  1170.   // Value will be moved

  1171.   proto::AttrDef *proto_attr_val = nullptr;

  1172.   if (!AttrUtilsHelper::MutableAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1173.     return false;

  1174.   }

  1175.   return GeAttrValueImp::SetZeroCopyBytes(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), std::move(buffer));

  1176. }

  1177. 

  1178. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY bool AttrUtils::GetZeroCopyBytes(ConstAttrHolderAdapter &&obj,

  1179.                                                                                 const string &name, Buffer &buffer) {

  1180.   const proto::AttrDef *proto_attr_val = nullptr;

  1181.   if (!AttrUtilsHelper::GetAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1182.     return false;

  1183.   }

  1184.   return GeAttrValueImp::GetZeroCopyBytes(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), buffer);

  1185. }

  1186. 

  1187. bool AttrUtils::SetZeroCopyListBytes(AttrHolderAdapter &&obj, const string &name, vector<Buffer> &list_buffer) {

  1188.   // Value will be moved

  1189.   proto::AttrDef *proto_attr_val = nullptr;

  1190.   if (!AttrUtilsHelper::MutableAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1191.     return false;

  1192.   }

  1193.   return GeAttrValueImp::SetZeroCopyListBytes(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), list_buffer);

  1194. }

  1195. 

  1196. bool AttrUtils::GetZeroCopyListBytes(ConstAttrHolderAdapter &&obj, const string &name, vector<Buffer> &list_buffer) {

  1197.   list_buffer.clear();

  1198.   const proto::AttrDef *proto_attr_val = nullptr;

  1199.   if (!AttrUtilsHelper::GetAttrMapItem(obj.get(), name, proto_attr_val) || proto_attr_val == nullptr) {

  1200.     return false;

  1201.   }

  1202.   return GeAttrValueImp::GetZeroCopyListBytes(*proto_attr_val, obj->GetAttrMap().GetProtoOwner(), list_buffer);

  1203. }

  1204. 

  1205. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY OpDescPtr AttrUtils::CloneOpDesc(const ConstOpDescPtr &org_op_desc) {

  1206.   if (org_op_desc == nullptr) {

  1207.     GELOGE(GRAPH_FAILED, "org_op_desc is null");

  1208.     return nullptr;

  1209.   }

  1210.   std::shared_ptr<proto::OpDef> op_def;

  1211.   op_def = ComGraphMakeShared<proto::OpDef>();

  1212.   if (op_def == nullptr) {

  1213.     GELOGE(GRAPH_FAILED, "proto::OpDef make shared failed");

  1214.     return nullptr;  // lint !e665

  1215.   }

  1216.   ModelSerializeImp imp;

  1217.   (void)imp.SerializeOpDesc(org_op_desc, op_def.get());

  1218. 

  1219.   imp.SetProtobufOwner(op_def);

  1220.   OpDescPtr op_desc = nullptr;

  1221.   GE_CHK_BOOL_EXEC(imp.UnserializeOpDesc(op_desc, *op_def), return op_desc, "op_desc unserialize failed");

  1222.   op_desc->extAttrs_ = org_op_desc->extAttrs_;

  1223. 

  1224.   // This function may be called by some passes of fusion engine, in this condition, do not need these attribute

  1225.   if (!op_desc->input_name_idx_.empty()) {

  1226.     op_desc->input_name_idx_.clear();

  1227.   }

  1228.   if (!op_desc->output_name_idx_.empty()) {

  1229.     op_desc->output_name_idx_.clear();

  1230.   }

  1231.   if (!op_desc->optional_input_names_.empty()) {

  1232.     op_desc->optional_input_names_.clear();

  1233.   }

  1234. 

  1235.   return op_desc;

  1236. }

  1237. 

  1238. GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY OpDescPtr AttrUtils::CopyOpDesc(const ConstOpDescPtr &org_op_desc) {

  1239.   if (org_op_desc == nullptr) {

  1240.     GELOGE(GRAPH_FAILED, "org_op_desc is null");

  1241.     return nullptr;

  1242.   }

  1243.   std::shared_ptr<proto::OpDef> op_def = ComGraphMakeShared<proto::OpDef>();

  1244.   if (op_def == nullptr) {

  1245.     GELOGE(GRAPH_FAILED, "proto::OpDef make shared failed");

  1246.     return nullptr;

  1247.   }

  1248.   ModelSerializeImp imp;

  1249.   (void)imp.SerializeOpDesc(org_op_desc, op_def.get());

  1250. 

  1251.   imp.SetProtobufOwner(op_def);

  1252.   OpDescPtr op_desc = nullptr;

  1253.   GE_CHK_BOOL_EXEC(imp.UnserializeOpDesc(op_desc, *op_def), return op_desc, "op_desc unserialize failed");

  1254. 

  1255.   op_desc->extAttrs_ = org_op_desc->extAttrs_;

  1256. 

  1257.   op_desc->input_name_idx_.insert(org_op_desc->input_name_idx_.begin(), org_op_desc->input_name_idx_.end());

  1258.   op_desc->optional_input_names_.insert(org_op_desc->optional_input_names_.begin(),

  1259.                                         org_op_desc->optional_input_names_.end());

  1260.   op_desc->output_name_idx_.insert(org_op_desc->output_name_idx_.begin(), org_op_desc->output_name_idx_.end());

  1261. 

  1262.   op_desc->infer_func_ = org_op_desc->infer_func_;

  1263.   op_desc->infer_format_func_ = org_op_desc->infer_format_func_;

  1264.   op_desc->verifier_func_ = org_op_desc->verifier_func_;

  1265. 

  1266.   return op_desc;

  1267. }

  1268. std::string AttrUtils::GetAllAttrsStr(AttrUtils::ConstAttrHolderAdapter &&obj) {

  1269.   auto holder = obj.get();

  1270.   if (holder == nullptr) {

  1271.     return "";

  1272.   }

  1273.   auto attrs_map = holder->GetAttrMap();

  1274.   if (attrs_map.GetProtoMsg() == nullptr) {

  1275.     return "";

  1276.   }

  1277. 

  1278.   std::map<std::string, std::string> ordered_attrs;

  1279.   for (auto &attr : *(attrs_map.GetProtoMsg())) {

  1280.     ordered_attrs[attr.first] = attr.second.SerializeAsString();

  1281.   }

  1282. 

  1283.   std::stringstream ss;

  1284.   for (auto &attr : ordered_attrs) {

  1285.     ss << attr.first << ":" << attr.second << ";";

  1286.   }

  1287.   return ss.str();

  1288. }

  1289. }  // namespace ge