MindSpore-GraphEngine/ge/graph/passes/net_output_pass.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/passes/net_output_pass.h"

#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "common/ge/ge_util.h"
#include "framework/common/debug/ge_log.h"
#include "framework/common/ge_inner_error_codes.h"
#include "framework/omg/omg_inner_types.h"
#include "graph/debug/ge_attr_define.h"
#include "graph/common/local_context.h"
#include "graph/passes/pass_utils.h"
#include "graph/utils/tensor_utils.h"
#include "graph/utils/type_utils.h"

namespace ge {
static std::map<std::string, ge::DataType> output_type_str_to_datatype = {
    {"FP32", ge::DT_FLOAT},    {"FP16", ge::DT_FLOAT16},  {"INT8", ge::DT_INT8},    {"INT16", ge::DT_INT16},
    {"UINT16", ge::DT_UINT16}, {"UINT8", ge::DT_UINT8},   {"INT32", ge::DT_INT32},  {"INT64", ge::DT_INT64},
    {"UINT32", ge::DT_UINT32}, {"UINT64", ge::DT_UINT64}, {"DOUBLE", ge::DT_DOUBLE}};

// the size of user defined output datatype or format string after split by ":".
const size_t kUserDefinedElementCount = 2;
const size_t kNodesCount = 2;

Status NetOutputPass::GetRetvalOutputInfo(const ge::NodePtr &node,
                                          std::map<int32_t, RetvalInfo> &retval_node_index_map) {
  GE_CHECK_NOTNULL(node);
  GE_CHECK_NOTNULL(node->GetOpDesc());
  int64_t output_index = 0;
  if (!AttrUtils::GetInt(node->GetOpDesc(), RETVAL_ATTR_NAME_INDEX, output_index)) {
    GELOGE(PARAM_INVALID, "Get output index failed.");
    return PARAM_INVALID;
  }
  if (retval_node_index_map.count(output_index) > 0) {
    GELOGE(PARAM_INVALID, "Retval has duplicate index.");
    return PARAM_INVALID;
  }
  int parent_node_index = -1;
  (void)AttrUtils::GetInt(node->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, parent_node_index);
  InDataAnchorPtr in_data_anchor = node->GetInDataAnchor(0);
  GE_CHECK_NOTNULL(in_data_anchor);
  GE_CHECK_NOTNULL(in_data_anchor->GetPeerOutAnchor());
  int32_t src_node_index = in_data_anchor->GetPeerOutAnchor()->GetIdx();
  NodePtr src_node_ptr = in_data_anchor->GetPeerOutAnchor()->GetOwnerNode();
  retval_node_index_map[output_index] = {src_node_ptr, src_node_index, parent_node_index};
  // if user targets include retval node,delete it from set and insert its input node instead
  // better to GetInNodes here
  auto iter = targets_.find(node);
  if (iter != targets_.end()) {
    targets_.erase(iter);
    targets_.insert(src_node_ptr);
    GELOGI("node [%s] is in user def targets, do not output result to user!", node->GetName().c_str());
  }
  is_include_special_node_ = true;
  return SUCCESS;
}

Status NetOutputPass::GetOutputNode(const ge::ComputeGraphPtr &graph, std::vector<RetvalInfo> &output_nodes_info) {
  std::map<int32_t, RetvalInfo> retval_node_index_map;
  for (NodePtr &node : graph->GetDirectNode()) {
    Status ret = SUCCESS;
    if ((node->GetOpDesc() != nullptr) && (node->GetOpDesc()->HasAttr(RETVAL_ATTR_NAME_INDEX))) {
      /// Set the output according to the Retval operator,
      /// identify by whether there is an index parameter
      ret = GetRetvalOutputInfo(node, retval_node_index_map);
    }
    if (ret != SUCCESS) {
      GELOGE(ret, "GetRetvalOutputInfo failed");
      return ret;
    }
  }
  GELOGI("Get retval node size:%zu.", retval_node_index_map.size());
  std::vector<RetvalInfo> out_nodes_tmp;
  /// The Netoutput output is determined by Retval, and the input order
  /// of Netoutput is sorted according to the index value of Retval.
  for (auto &it : retval_node_index_map) {
    out_nodes_tmp.push_back(it.second);
  }

  // when user set targets, mean that no output result
  for (auto &ele : graph->GetGraphOutNodesInfo()) {
    auto iter = targets_.find(ele.first);
    if (iter != targets_.end()) {
      GELOGI("user set out node [%s] is found in user def targets, out node is prio!", ele.first->GetName().c_str());
      targets_.erase(iter);
    }

    auto op_desc = ele.first->GetOpDesc();
    GE_CHECK_NOTNULL(op_desc);
    if (op_desc->HasAttr(ATTR_ATC_USER_DEFINE_OUTPUT_NODES)) {
      is_user_define_ouput_nodes = true;
    }
    int parent_index = -1;
    auto output_desc = op_desc->MutableOutputDesc(ele.second);
    if (output_desc == nullptr) {
      GELOGE(FAILED, "[Get][OutputDesc]Can not find output tensor desc from node:%s, index %d",
             op_desc->GetName().c_str(), ele.second);
      return FAILED;
    }
    (void)ge::AttrUtils::GetInt(output_desc, ge::ATTR_NAME_PARENT_NODE_INDEX, parent_index);
    output_nodes_info.push_back({ele.first, ele.second, parent_index});
  }
  GELOGI("Output node set by user or leaf node, size:%zu.", output_nodes_info.size());
  for (auto &ele : out_nodes_tmp) {
    // add member, no need to remove duplicated because we need to keep all edges
    output_nodes_info.push_back(ele);
  }
  GELOGI("Get output node, size:%zu.", output_nodes_info.size());

  Status check_ret = CheckOutputNodeInfo(graph, output_nodes_info);
  if (check_ret != SUCCESS) {
    return check_ret;
  }
  return SUCCESS;
}

Status NetOutputPass::CheckOutputNodeInfo(const ComputeGraphPtr &graph, const std::vector<RetvalInfo> &outputs) {
  for (auto &item : outputs) {
    NodePtr node = item.output_node;
    if (node == nullptr) {
      GELOGE(PARAM_INVALID, "Node in outputs is null.");
      return PARAM_INVALID;
    } else {
      if (graph->FindNode(node->GetName()) == nullptr) {
        GELOGE(INTERNAL_ERROR, "Out node (%s) is not in graph.", node->GetName().c_str());
        return INTERNAL_ERROR;
      }
      GE_CHECK_NOTNULL(node->GetOpDesc());
      int32_t out_size = node->GetOpDesc()->GetOutputsSize();
      int32_t index = item.node_output_index;
      if (index < 0 || index >= out_size) {
        GELOGE(PARAM_INVALID,
               "User declared out node (%s) output index:%d must be smaller "
               "than node ouput size:%d and cann't be negative!",
               node->GetName().c_str(), index, out_size);
        return PARAM_INVALID;
      }
    }
  }
  return SUCCESS;
}

Status NetOutputPass::RemoveUnusedNode(const ge::ComputeGraphPtr &graph) {
  std::vector<ge::NodePtr> node_to_delete;
  // Delete _Retval operator.
  for (auto &node : graph->GetDirectNode()) {
    GE_IF_BOOL_EXEC(node->GetOpDesc() == nullptr, GELOGW("Node OpDesc is nullptr"); continue);
    bool need_be_deleted = node->GetInDataNodes().size() != 0 && node->GetOutDataNodesSize() == 0 &&
                           (node->GetOpDesc()->HasAttr(RETVAL_ATTR_NAME_INDEX));
    if (need_be_deleted) {
      node_to_delete.push_back(node);
    }
  }
  for (NodePtr &node : node_to_delete) {
    auto iter = targets_.find(node);
    if (iter != targets_.end()) {
      GELOGI("[Net output pass] node[%s] is in user set targets.so do not remove!", node->GetName().c_str());
      continue;
    }
    if (graph->RemoveNode(node) != GRAPH_SUCCESS) {
      GELOGE(INTERNAL_ERROR, "Remove node failed, node name:%s.", node->GetName().c_str());
      return INTERNAL_ERROR;
    }
  }
  return SUCCESS;
}

Status NetOutputPass::UpdateNetOutputDesc(const ge::NodePtr &net_output) {
  OpDescPtr net_output_desc = net_output->GetOpDesc();
  if (net_output_desc == nullptr) {
    GELOGE(INTERNAL_ERROR, "Opdesc of net output node is nullptr.");
    return INTERNAL_ERROR;
  }
  if (net_output_desc->GetInputsSize() == 0) {
    GELOGE(INTERNAL_ERROR, "Net output node input is empty.");
    return INTERNAL_ERROR;
  }

  std::vector<bool> is_input_const;
  for (const auto &in_anchor : net_output->GetAllInDataAnchors()) {
    GE_CHECK_NOTNULL(in_anchor);
    uint32_t index = static_cast<uint32_t>(in_anchor->GetIdx());
    if (index >= net_output_desc->GetAllInputsDesc().size()) {
      GELOGE(INTERNAL_ERROR, "Index is invalid, index:%u, size:%zu.", index,
             net_output_desc->GetAllInputsDesc().size());
      return INTERNAL_ERROR;
    }
    GE_CHECK_NOTNULL(in_anchor->GetPeerOutAnchor());
    is_input_const.push_back(PassUtils::IsConstant(in_anchor->GetPeerOutAnchor()->GetOwnerNode()));
    OpDescPtr src_op_desc = in_anchor->GetPeerOutAnchor()->GetOwnerNode()->GetOpDesc();
    GE_CHECK_NOTNULL(src_op_desc);
    uint32_t peer_index = static_cast<uint32_t>(in_anchor->GetPeerOutAnchor()->GetIdx());
    ge::GeTensorDesc output_in_desc = src_op_desc->GetOutputDesc(peer_index);
    if (net_output_desc->UpdateInputDesc(index, output_in_desc) != GRAPH_SUCCESS) {
      GELOGE(INTERNAL_ERROR, "Update input desc failed, index:%u.", index);
      return INTERNAL_ERROR;
    }
    GELOGD("Update desc, format:%s, data type:%s, index:%u.",
           TypeUtils::FormatToSerialString(output_in_desc.GetFormat()).c_str(),
           TypeUtils::DataTypeToSerialString(output_in_desc.GetDataType()).c_str(), index);
  }
  net_output_desc->SetIsInputConst(is_input_const);
  return SUCCESS;
}

Status NetOutputPass::AddCtrlEdgeForTargets(const ge::NodePtr &net_out_node) {
  if (net_out_node == nullptr) {
    GELOGE(PARAM_INVALID, "net out node is null.");
    return PARAM_INVALID;
  }
  // Add ctrl edge for targets
  for (auto &node : targets_) {
    if (node == nullptr) {
      continue;
    }
    // no need to check null because have handled it in run SaveAndRemoveTargets function
    graphStatus status = GraphUtils::AddEdge(node->GetOutControlAnchor(), net_out_node->GetInControlAnchor());
    if (status != GRAPH_SUCCESS) {
      GELOGE(INTERNAL_ERROR, "Add ctrl edge to netoutput node[%s] for target node [%s] failed!",
             net_out_node->GetName().c_str(), node->GetName().c_str());
      return INTERNAL_ERROR;
    }
    GELOGD("Add ctrl edge to netoutput node[%s] for target node [%s] success!", net_out_node->GetName().c_str(),
           node->GetName().c_str());
  }
  return SUCCESS;
}

void NetOutputPass::SaveAndRemoveTargets(const ge::ComputeGraphPtr &graph) {
  // save user targets node
  for (auto &node : graph->GetGraphTargetNodesInfo()) {
    if (node == nullptr) {
      GELOGW("User pointed targets contains null node.ignore it !");
      continue;
    }
    targets_.insert(node);
  }
  GELOGI("User pointed targets size is %zu !", targets_.size());
}

Status NetOutputPass::AddEdgesForNetOutput(const ge::ComputeGraphPtr &graph, const ge::NodePtr &net_out_node,
                                           const std::vector<RetvalInfo> &output_nodes_info) {
  int32_t net_input_index = 0;
  for (auto &item : output_nodes_info) {
    NodePtr src_node = item.output_node;
    GE_CHECK_NOTNULL(src_node);
    graphStatus status = GraphUtils::AddEdge(src_node->GetOutDataAnchor(item.node_output_index),
                                             net_out_node->GetInDataAnchor(net_input_index));
    if (status != GRAPH_SUCCESS) {
      GELOGE(INTERNAL_ERROR, "AddEdge failed, src name:%s, src index:%d, dst index:%d.", src_node->GetName().c_str(),
             item.node_output_index, net_input_index);
      return INTERNAL_ERROR;
    }
    GELOGD("AddEdge to output node, src name:%s, src index:%d, dst index:%d.", src_node->GetName().c_str(),
           item.node_output_index, net_input_index);
    if (item.parent_node_index >= 0) {
      GELOGI("Add parent node index %d for the netoutput input %d on graph %s", item.parent_node_index, net_input_index,
             graph->GetName().c_str());
      auto input_desc = net_out_node->GetOpDesc()->MutableInputDesc(net_input_index);
      if (input_desc == nullptr) {
        GELOGE(INTERNAL_ERROR, "Can not find intput tensor desc from NetOutput, index %d", net_input_index);
        return INTERNAL_ERROR;
      }
      if (!AttrUtils::SetInt(input_desc, ATTR_NAME_PARENT_NODE_INDEX, item.parent_node_index)) {
        GELOGE(INTERNAL_ERROR, "Failed to add parent index to  NetOutput, index %d", net_input_index);
        return INTERNAL_ERROR;
      }
    }
    net_input_index++;
  }
  if (RemoveUnusedNode(graph) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Remove unused nodes failed.");
    return INTERNAL_ERROR;
  }
  if (AddCtrlEdgeForTargets(net_out_node) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Add ctrl edge for targets failed.");
    return INTERNAL_ERROR;
  }
  // Add true stream, netoutput is 0
  GE_IF_BOOL_EXEC(!ge::AttrUtils::SetInt(net_out_node->GetOpDesc(), ATTR_NAME_TRUE_BRANCH_STREAM, 0),
                  GELOGE(INTERNAL_ERROR, "set ATTR_NAME_TRUE_BRANCH_STREAM failed");
                  return INTERNAL_ERROR);
  return SUCCESS;
}

bool NetOutputPass::CheckNodeIsInOutputNodes(const ge::ComputeGraphPtr &graph, const ge::NodePtr &node) {
  for (auto &ele : graph->GetGraphOutNodesInfo()) {
    auto out_node = ele.first;
    if (node == out_node) {
      return true;
    }
  }
  return false;
}
Status NetOutputPass::UnLinkDataAnchorOfNetoutput(const ge::ComputeGraphPtr &graph, const ge::NodePtr &net_out_node) {
  if (net_out_node == nullptr) {
    GELOGE(PARAM_INVALID, "net out node is null.");
    return PARAM_INVALID;
  }
  Status ret = SUCCESS;

  // unlink all anchor to data anchor of netoutput
  for (auto &in_data_anchor : net_out_node->GetAllInDataAnchors()) {
    if (in_data_anchor == nullptr) {
      continue;
    }
    auto peer_out_anchor = in_data_anchor->GetPeerOutAnchor();
    if (peer_out_anchor == nullptr) {
      GELOGI("PeerOutAnchor is null!");
      continue;
    }
    auto node = peer_out_anchor->GetOwnerNode();
    auto iter = targets_.find(node);
    if (iter != targets_.end()) {
      if (!CheckNodeIsInOutputNodes(graph, node)) {
        ret = in_data_anchor->Unlink(peer_out_anchor);
        if (ret != SUCCESS) {
          GELOGE(INTERNAL_ERROR, "Unlink peer_out_anchor fail!");
          return ret;
        }
      } else {
        targets_.erase(iter);
      }
    }
  }
  return ret;
}

Status NetOutputPass::UnLinkControlAnchorOfNetoutput(const ge::ComputeGraphPtr &graph,
                                                     const ge::NodePtr &net_out_node) {
  if (net_out_node == nullptr) {
    GELOGE(PARAM_INVALID, "net out node is null.");
    return PARAM_INVALID;
  }
  Status ret = SUCCESS;
  auto in_control_anchor = net_out_node->GetInControlAnchor();
  if (in_control_anchor == nullptr) {
    GELOGE(PARAM_INVALID, "in control anchor is null.");
    return PARAM_INVALID;
  }
  // unlink all data anchor to control anchor of netoutput
  for (auto &peer_out_data_anchor : in_control_anchor->GetPeerOutDataAnchors()) {
    if (peer_out_data_anchor == nullptr) {
      GELOGI("PeerOutControlAnchor is null!");
    } else {
      auto node = peer_out_data_anchor->GetOwnerNode();
      auto iter = targets_.find(node);
      if (iter != targets_.end()) {
        if (CheckNodeIsInOutputNodes(graph, node) == false) {
          ret = in_control_anchor->Unlink(peer_out_data_anchor);
          if (ret != SUCCESS) {
            GELOGE(INTERNAL_ERROR, "Unlink peer_out_anchor fail!");
            return ret;
          }
        } else {
          targets_.erase(iter);
        }
      }
    }
  }
  /// check all control anchor to control anchor of netoutput and delete it from targets
  /// to avoid duplicated add control edge;
  for (auto &peer_out_control_anchor : in_control_anchor->GetPeerOutControlAnchors()) {
    if (peer_out_control_anchor == nullptr) {
      GELOGI("PeerOutControlAnchor is null");
    } else {
      auto node = peer_out_control_anchor->GetOwnerNode();
      auto iter = targets_.find(node);
      if (iter != targets_.end()) {
        targets_.erase(iter);
      }
    }
  }
  return ret;
}

Status NetOutputPass::UnLink(const ge::ComputeGraphPtr &graph, const ge::NodePtr &net_out_node) {
  GELOGI("[NetOutputPass] Enter Unlink process.");
  Status ret = UnLinkDataAnchorOfNetoutput(graph, net_out_node);
  if (ret != SUCCESS) {
    GELOGI("[NetOutputPass] UnLinkDataAnchorOfNetoutput process fail.");
    return ret;
  }
  ret = UnLinkControlAnchorOfNetoutput(graph, net_out_node);
  if (ret != SUCCESS) {
    GELOGI("[NetOutputPass] UnLinkControlAnchorOfNetoutput process fail.");
    return ret;
  }
  return ret;
}

Status NetOutputPass::ProcessWithNetoutput(const ge::ComputeGraphPtr &graph, const ge::NodePtr &output_node) {
  if (UpdateNetOutputDesc(output_node) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Update net output desc failed.");
    return INTERNAL_ERROR;
  }

  if (UnLink(graph, output_node) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "UnLink connection between netoutput node and user set target node");
    return INTERNAL_ERROR;
  }
  if (AddCtrlEdgeForTargets(output_node) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Add ctrl edge for targets failed.");
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}

Status NetOutputPass::AddCtrlEdgesBetweenLeafAndNetOutput(const ge::ComputeGraphPtr &graph,
                                                          const ge::NodePtr &net_out_node) {
  GE_CHECK_NOTNULL(net_out_node);
  if (!GetLocalOmgContext().user_out_nodes.empty() || is_user_define_ouput_nodes) {
    GELOGI("No need to add ctrl edge to netoutput because user out nodes have been set.");
    return SUCCESS;
  }
  bool graph_has_only_one_node_except_netoutput = (graph->GetDirectNodesSize() == kNodesCount);
  for (const auto &node : graph->GetDirectNode()) {
    if (node == nullptr || node->GetOpDesc() == nullptr || node->GetOpDesc()->GetType() == NETOUTPUT) {
      continue;
    }
    if ((node->GetInControlNodes().size() != 0 || node->GetInDataNodes().size() != 0 ||
         graph_has_only_one_node_except_netoutput) &&
        node->GetOutDataNodesSize() == 0 && node->GetOutControlNodes().size() == 0) {
      GE_CHK_STATUS_RET(GraphUtils::AddEdge(node->GetOutControlAnchor(), net_out_node->GetInControlAnchor()),
                        "add edge failed");
      GELOGD("Add ctrl edge success. src name :%s, dst name :%s", node->GetName().c_str(),
             net_out_node->GetName().c_str());
    }
  }
  return SUCCESS;
}

Status NetOutputPass::CreateNetOutputNode(OpDescPtr &net_output_desc, const ge::ComputeGraphPtr &graph) {
  // Only flush subgraph name
  string node_name =
      (graph->GetParentGraph() != nullptr) ? (graph->GetName() + "_" + NODE_NAME_NET_OUTPUT) : NODE_NAME_NET_OUTPUT;
  net_output_desc = MakeShared<OpDesc>(node_name, NETOUTPUT);
  if (net_output_desc == nullptr) {
    GELOGE(MEMALLOC_FAILED, "Make shared net output op failed.");
    return MEMALLOC_FAILED;
  }
  (void)AttrUtils::SetListStr(net_output_desc, ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES,
                              std::move(std::vector<std::string>()));
  return SUCCESS;
}

Status NetOutputPass::Run(ge::ComputeGraphPtr graph) {
  if (graph == nullptr) {
    GELOGE(GE_GRAPH_PARAM_NULLPTR, "Compute graph is null.");
    return GE_GRAPH_PARAM_NULLPTR;
  }
  GELOGI("NetOutputPass Run.graph is [%s]", graph->GetName().c_str());
  NodePtr output_node = graph->FindFirstNodeMatchType(NETOUTPUT);
  // save user targets node
  SaveAndRemoveTargets(graph);
  // If graph already has a netoutput node, doesn't need to create it again.
  if (output_node != nullptr) {
    (void)AttrUtils::SetListStr(output_node->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES,
                                std::move(std::vector<std::string>()));
    if (ProcessWithNetoutput(graph, output_node) != SUCCESS) {
      GELOGE(INTERNAL_ERROR, "Process with netoutput node failed.");
      return INTERNAL_ERROR;
    }
  } else {
    if (AddNetOutputNodeToGraph(graph, output_node) != SUCCESS) {
      GELOGE(INTERNAL_ERROR, "Set user define dtype and format for netoutput failed.");
      return INTERNAL_ERROR;
    }
  }
  // Add userdef attrs to netoutput node
  return SetUserDefDTypeAndFormatFromAtcParams(output_node);
}

Status NetOutputPass::AddNetOutputNodeToGraph(const ge::ComputeGraphPtr &graph, NodePtr &output_node) {
  OpDescPtr net_output_desc = nullptr;
  if (CreateNetOutputNode(net_output_desc, graph) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Get net output nodes failed.");
    return INTERNAL_ERROR;
  }
  std::vector<RetvalInfo> output_nodes_info;
  if (GetOutputNode(graph, output_nodes_info) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Get net output nodes failed.");
    return INTERNAL_ERROR;
  }
  GELOGI("[NETOUTPUT PASS] OutNodesInfo size:%zu, Targets Size:%zu, is_include_special_node_:%d",
         graph->GetGraphOutNodesInfo().size(), graph->GetGraphTargetNodesInfo().size(), is_include_special_node_);
  // If user does not set out nodes and targets and no retval node, also add netoutput node
  if ((graph->GetGraphOutNodesInfo().empty()) && (graph->GetGraphTargetNodesInfo().empty()) &&
      !is_include_special_node_) {
    GELOGI("[NETOUTPUT PASS] output_nodes and target_nodes and special nodes is empty!Add netoutput!");
    output_node = graph->AddNode(net_output_desc);
    GE_CHK_STATUS_RET(AddCtrlEdgesBetweenLeafAndNetOutput(graph, output_node),
                      "add ctrl edge between leaf and netoutput failed");
    return SUCCESS;
  }
  GELOGI("[NETOUTPUT PASS] Output node size:%lu.", output_nodes_info.size());
  if (output_nodes_info.empty()) {
    // because retval node is contained by output_nodes_info, here means targets is non-empty
    output_node = graph->AddNode(net_output_desc);
    if (output_node == nullptr) {
      GELOGE(INTERNAL_ERROR, "Add output node failed.");
      return INTERNAL_ERROR;
    }
    GE_CHK_STATUS_RET(AddCtrlEdgeForTargets(output_node), "add ctrl edge for targets failed");
    // Add true stream, netoutput is 0
    GE_IF_BOOL_EXEC(!ge::AttrUtils::SetInt(output_node->GetOpDesc(), ATTR_NAME_TRUE_BRANCH_STREAM, 0),
                    GELOGE(INTERNAL_ERROR, "set ATTR_NAME_TRUE_BRANCH_STREAM failed");
                    return INTERNAL_ERROR);
    return SUCCESS;
  }

  AddInOutForNetOutputOp(graph, net_output_desc, output_nodes_info);
  output_node = graph->AddNode(net_output_desc);
  if (output_node == nullptr) {
    GELOGE(INTERNAL_ERROR, "Add output node failed.");
    return INTERNAL_ERROR;
  }
  if (AddEdgesForNetOutput(graph, output_node, output_nodes_info) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Add edges for net output node failed.");
    return INTERNAL_ERROR;
  }
  if (AddCtrlEdgesBetweenLeafAndNetOutput(graph, output_node) != SUCCESS) {
    GELOGE(INTERNAL_ERROR, "Add control edges between leaf and netoutput failed.");
    return INTERNAL_ERROR;
  }
  GELOGI("Add NetOutput node success.");
  return SUCCESS;
}
void NetOutputPass::AddInOutForNetOutputOp(const ComputeGraphPtr &graph, OpDescPtr &net_output_desc,
                                           vector<RetvalInfo> &output_nodes_info) {
  std::vector<bool> is_input_const;
  for (auto iter = output_nodes_info.begin(); iter != output_nodes_info.end();) {
    NodePtr src_node = iter->output_node;
    if (src_node == nullptr) {
      continue;
    }
    int32_t src_index = iter->node_output_index;
    // if src_node is in targets_, no need to Add in and out for netoutput
    auto it = targets_.find(src_node);
    if (it != targets_.end()) {
      iter = output_nodes_info.erase(iter);
      GELOGD("node [%s] is in processed targets, do not add inout for netoutput!", src_node->GetName().c_str());
      continue;
    }
    /// Get the output attribute of src_node,
    /// and set to the input/output of net_out_node.
    if (src_node == nullptr || src_node->GetOpDesc() == nullptr || net_output_desc == nullptr) {
      GELOGE(INTERNAL_ERROR, "src node or net output desc is null.");
      return;
    }
    ge::GeTensorDesc out_desc = src_node->GetOpDesc()->GetOutputDesc(src_index);
    out_desc.SetFormat(FORMAT_ND);
    out_desc.SetOriginFormat(FORMAT_ND);
    GE_IF_BOOL_EXEC(net_output_desc->AddInputDesc(out_desc) != SUCCESS, GELOGW("add input desc failed"); return );
    is_input_const.push_back(PassUtils::IsConstant(src_node));
    ++iter;
  }
  net_output_desc->SetIsInputConst(is_input_const);
}

bool NeedUpdateOutputByOutputTypeParm(std::string &output_type, OpDescPtr &op_desc, uint32_t &src_index,
                                      ge::DataType &dt) {
  if (output_type_str_to_datatype.find(output_type) != output_type_str_to_datatype.end()) {
    dt = output_type_str_to_datatype[output_type];
    return true;
  }

  vector<string> output_dt_str;
  if (ge::AttrUtils::GetListStr(op_desc, "_user_defined_output_data_type", output_dt_str)) {
    for (const auto &dt_str : output_dt_str) {
      vector<string> dt_str_split = StringUtils::Split(dt_str, ':');
      if (dt_str_split.size() == kUserDefinedElementCount) {
        if (dt_str_split[0] == to_string(src_index)) {
          dt = TypeUtils::SerialStringToDataType(dt_str_split[1]);
          return true;
        }
      } else {
        GELOGW("The size of [%s] is not 2 after split.", dt_str.c_str());
        continue;
      }
    }
  }
  return false;
}

bool NeedUpdateOutputFp16Nc1hwc0(OpDescPtr &op_desc, uint32_t &src_index) {
  vector<string> output_dt_str;
  if (ge::AttrUtils::GetListStr(op_desc, "_user_defined_output_fp16_5hd", output_dt_str)) {
    for (const auto &dt_str : output_dt_str) {
      vector<string> dt_str_split = StringUtils::Split(dt_str, ':');
      if (dt_str_split.size() == kUserDefinedElementCount) {
        if (dt_str_split[0] == to_string(src_index)) {
          return true;
        }
      } else {
        GELOGW("The size of [%s] is not 2 after split.", dt_str.c_str());
        continue;
      }
    }
  }
  return false;
}

Status NetOutputPass::SetUserDefDTypeAndFormatFromAtcParams(const NodePtr &output_node) {
  if (output_node == nullptr) {
    GELOGI("[NETOUTPUT PASS] The graph no need netoutput node!");
    return SUCCESS;
  }
  auto output_type = GetLocalOmgContext().output_type;
  auto op_desc = output_node->GetOpDesc();
  GE_CHECK_NOTNULL(op_desc);
  std::vector<std::string> userdef_dtypes;
  std::vector<std::string> userdef_formats;

  ge::DataType output_data_type = ge::DT_FLOAT;
  for (const auto &in_anchor : output_node->GetAllInDataAnchors()) {
    auto index = static_cast<uint32_t>(in_anchor->GetIdx());
    auto peer_out = in_anchor->GetPeerOutAnchor();
    if (peer_out == nullptr) {
      // If user set target, peer_out anchor will be unlinked.
      continue;
    }
    auto src_index = static_cast<uint32_t>(peer_out->GetIdx());
    auto src_node = peer_out->GetOwnerNode();
    GE_CHECK_NOTNULL(src_node);
    OpDescPtr src_op_desc = src_node->GetOpDesc();
    GE_CHECK_NOTNULL(src_op_desc);

    // Update datatype
    if (NeedUpdateOutputByOutputTypeParm(output_type, src_op_desc, src_index, output_data_type)) {
      GELOGD("Add user-define datatype:%s to netoutput node.",
             TypeUtils::DataTypeToSerialString(output_data_type).c_str());
      userdef_dtypes.push_back(
          std::to_string(index).append(":").append(TypeUtils::DataTypeToSerialString(output_data_type)));
      continue;
    }
    // Output_node is not set,check if is_output_adjust_hw_layout is set
    bool set_fp16_nc1hwc0 = NeedUpdateOutputFp16Nc1hwc0(src_op_desc, src_index);
    if (set_fp16_nc1hwc0) {
      // Set DT_FLOAT16 & FORMAT_NC1HWC0
      userdef_dtypes.push_back(std::to_string(index).append(":").append(TypeUtils::DataTypeToSerialString(DT_FLOAT16)));
      userdef_formats.push_back(
          std::to_string(index).append(":").append(TypeUtils::FormatToSerialString(FORMAT_NC1HWC0)));
    }
  }
  if (!userdef_dtypes.empty() && !ge::AttrUtils::SetListStr(op_desc, ATTR_ATC_USER_DEFINE_DATATYPE, userdef_dtypes)) {
    GELOGE(INTERNAL_ERROR, "Set user_define_dtype attr list for netoutput failed.");
    return INTERNAL_ERROR;
  }
  if (!userdef_formats.empty() && !ge::AttrUtils::SetListStr(op_desc, ATTR_ATC_USER_DEFINE_FORMAT, userdef_formats)) {
    GELOGE(INTERNAL_ERROR, "Set user_define_format attr list for netoutput failed.");
    return INTERNAL_ERROR;
  }
  return SUCCESS;
}
}  // namespace ge