Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
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: dc543f3f1e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dc543f3f1e'
${ noResults }
mindspore/mindspore/ccsrc/backend/session/kernel_graph.h

374 lines
18 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019 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. #ifndef MINDSPORE_CCSRC_BACKEND_SESSION_KERNEL_GRAPH_H

  17. #define MINDSPORE_CCSRC_BACKEND_SESSION_KERNEL_GRAPH_H

  18. 

  19. #include <vector>

  20. #include <memory>

  21. #include <utility>

  22. #include <string>

  23. #include <queue>

  24. #include <map>

  25. #include <unordered_map>

  26. #include <set>

  27. #include <unordered_set>

  28. #include <stack>

  29. #include <atomic>

  30. #include "ir/func_graph.h"

  31. #include "ir/anf.h"

  32. #include "ir/graph_utils.h"

  33. #include "utils/contract.h"

  34. #include "runtime/device/kernel_info.h"

  35. 

  36. namespace mindspore {

  37. namespace session {

  38. using AnfWithOutIndex = std::pair<AnfNodePtr, size_t>;

  39. class KernelGraph : public FuncGraph {

  40.  public:

  41.   KernelGraph() : graph_id_(0), start_label_(nullptr), end_goto_(nullptr), current_epoch_(0), is_dynamic_shape_(false) {

  42.     inputs_ = std::make_shared<std::vector<AnfNodePtr>>();

  43.     execution_order_ = {};

  44.     executable_ = true;

  45.     summary_node_exist_ = false;

  46.     stream_distinction_label_ = kInvalidDistincLabel;

  47.     extra_param_tensor_ = {};

  48.   }

  49. 

  50.   KernelGraph(const KernelGraph &graph) : FuncGraph(graph) {

  51.     inputs_ = graph.inputs_;

  52.     child_graph_result_ = graph.child_graph_result_;

  53.     execution_order_ = graph.execution_order_;

  54.     graph_id_ = graph.graph_id_;

  55.     stream_distinction_label_ = graph.stream_distinction_label_;

  56.     front_backend_anf_map_ = graph.front_backend_anf_map_;

  57.     backend_front_anf_map_ = graph.backend_front_anf_map_;

  58.     tensor_to_value_node_map_ = graph.tensor_to_value_node_map_;

  59.     graph_value_nodes_ = graph.graph_value_nodes_;

  60.     node_input_num_ = graph.node_input_num_;

  61.     node_input_edges_ = graph.node_input_edges_;

  62.     ref_out_in_map_ = graph.ref_out_in_map_;

  63.     node_output_edges_ = graph.node_output_edges_;

  64.     summary_nodes_ = graph.summary_nodes_;

  65.     executable_ = graph.executable_;

  66.     summary_node_exist_ = graph.summary_node_exist_;

  67.     valid_inputs_ = graph.valid_inputs_;

  68.     child_graph_order_ = graph.child_graph_order_;

  69.     input_ctrl_tensors_ = graph.input_ctrl_tensors_;

  70.     parent_graph_ = graph.parent_graph_;

  71.     start_label_ = graph.start_label_;

  72.     end_goto_ = graph.end_goto_;

  73.     front_to_internal_outputs_map_ = graph.front_to_internal_outputs_map_;

  74.     internal_outputs_to_front_map_ = graph.internal_outputs_to_front_map_;

  75.     internal_outputs_tensor_map_ = graph.internal_outputs_tensor_map_;

  76.     current_epoch_ = graph.current_epoch_;

  77.     tuple_parameter_to_make_tuple_map_ = graph.tuple_parameter_to_make_tuple_map_;

  78.     visited_nodes_ = graph.visited_nodes_;

  79.     edge_to_ = graph.edge_to_;

  80.     loop_nodes_ = graph.loop_nodes_;

  81.     input_nodes_ = graph.input_nodes_;

  82.     pre_graphs_ = graph.pre_graphs_;

  83.     post_graphs_ = graph.post_graphs_;

  84.     size_t pre_graph_finished_count = graph.pre_graph_finished_count_;

  85.     pre_graph_finished_count_ = pre_graph_finished_count;

  86.     size_t post_graph_finished_count = graph.post_graph_finished_count_;

  87.     post_graph_finished_count_ = post_graph_finished_count;

  88.     first_step_ = graph.first_step_;

  89.     has_optimizer_ = graph.has_optimizer_;

  90.     is_dynamic_shape_ = graph.is_dynamic_shape_;

  91.     extra_param_tensor_ = graph.extra_param_tensor_;

  92.   }

  93. 

  94.   ~KernelGraph() override;

  95. 

  96.   MS_DECLARE_PARENT(KernelGraph, FuncGraph);

  97. 

  98.   const std::vector<AnfNodePtr> &inputs() const;

  99.   std::vector<AnfNodePtr> *MutableInputs() const { return inputs_.get(); }

  100.   void ReplaceGraphInput(const AnfNodePtr &old_parameter, const AnfNodePtr &new_parameter);

  101.   std::vector<AnfNodePtr> outputs() const;

  102.   CNodePtr NewCNode(const std::vector<AnfNodePtr> &inputs) override;

  103.   void CreateKernelInfoFromNewParameter(const CNodePtr &cnode);

  104.   CNodePtr NewCNode(const CNodePtr &cnode);

  105.   void ResetAssignInputFeaatureMapFlag(const CNodePtr &cnode) const;

  106.   ParameterPtr NewParameter(const ParameterPtr &parameter = nullptr);

  107.   ParameterPtr NewParameter(const abstract::AbstractBasePtr &abstract);

  108.   ValueNodePtr NewValueNode(const AbstractBasePtr &abstract, const ValuePtr &value);

  109.   ValueNodePtr NewValueNode(const ValueNodePtr &value_node = nullptr);

  110.   // trans tuple output to maketuple + no_tuple out

  111.   AnfNodePtr TransTupleToMakeTuple(const AnfNodePtr &node);

  112.   void set_execution_order(const std::vector<CNodePtr> &order) { execution_order_ = order; }

  113.   void set_execution_order(std::vector<CNodePtr> &&order) { execution_order_ = std::move(order); }

  114.   const std::vector<CNodePtr> &execution_order() const { return execution_order_; }

  115.   void SetExecOrderByDefault();

  116.   uint32_t graph_id() const { return graph_id_; }

  117.   void set_graph_id(uint32_t graph_id) { graph_id_ = graph_id; }

  118. 

  119.   // and a new front to backend anf relation to maop

  120.   void FrontBackendlMapAdd(const AnfNodePtr &front_anf, const AnfNodePtr &backend_anf);

  121.   // replace old backend anf with new backend anf

  122.   void FrontBackendlMapUpdate(const AnfNodePtr &old_backend_anf, const AnfNodePtr &new_backend_anf);

  123.   // get backend anf by front anf

  124.   AnfNodePtr GetBackendAnfByFrontAnf(const AnfNodePtr &front_anf);

  125.   // check backend node whether exist in map

  126.   bool BackendNodeExistInFrontBackendMap(const AnfNodePtr &backend_anf);

  127.   // get value node by tensor

  128.   ValueNodePtr GetValueNodeByTensor(const tensor::TensorPtr &tensor);

  129.   // add value node tensor relation map

  130.   void TensorValueNodeMapAdd(const tensor::TensorPtr &tensor, const ValueNodePtr &value_node);

  131.   // get all value nodes of graph

  132.   const std::unordered_set<ValueNodePtr> graph_value_nodes() const { return graph_value_nodes_; }

  133.   // add value node to graph

  134.   void AddValueNodeToGraph(const ValueNodePtr &value_node);

  135.   // ref output is in map

  136.   bool IsInRefOutputMap(const AnfWithOutIndex &pair) const;

  137.   // get ref correspond pairs

  138.   AnfWithOutIndex GetRefCorrespondOutput(const AnfWithOutIndex &out_pair) const;

  139.   // add ref correspond pairs

  140.   void AddRefCorrespondPairs(const AnfWithOutIndex &final_pair, const AnfWithOutIndex &origin_pair);

  141.   // get map

  142.   std::map<AnfWithOutIndex, AnfWithOutIndex> GetRefMap() const { return ref_out_in_map_; }

  143.   // check whether graph is executable

  144.   bool executable() const { return executable_; }

  145.   // set executable of graph

  146.   void set_executable(bool executable) { executable_ = executable; }

  147.   // set summary_node of graph

  148.   void set_summary_node_exist(bool summary_node_exist) { summary_node_exist_ = summary_node_exist; }

  149.   // check whether exist summary node in graph

  150.   bool summary_node_exist() const { return summary_node_exist_; }

  151.   // set invalid inputs for control sink

  152.   std::vector<bool> *MutableValidInputs() { return &valid_inputs_; }

  153.   std::vector<bool> valid_inputs() const { return valid_inputs_; }

  154.   // replace node in graph

  155.   void ReplaceNode(NotNull<AnfNodePtr> old_anf_node, NotNull<AnfNodePtr> new_anf_node);

  156.   // set stream label of graph

  157.   void set_stream_distinction_label(uint32_t stream_label) { stream_distinction_label_ = stream_label; }

  158.   // get stream label of graph

  159.   uint32_t stream_distinction_label() { return stream_distinction_label_; }

  160.   // refresh execute kernel stream label

  161.   void UpdateExecuteKernelStreamLabel();

  162.   // calculate the leaf graph order of root graph

  163.   std::vector<std::shared_ptr<KernelGraph>> GetLeafGraphOrder();

  164.   // the child graph of current graph

  165.   const std::vector<std::weak_ptr<KernelGraph>> &child_graph_order() const { return child_graph_order_; }

  166.   void set_child_graph_order(const std::vector<std::weak_ptr<KernelGraph>> &order) { child_graph_order_ = order; }

  167.   // checkout whether current graph is leaf graph

  168.   bool IsLeafGraph() const;

  169. 

  170.   // set input_tensors pointer of control parameter

  171.   void set_input_ctrl_tensors(const std::shared_ptr<std::vector<tensor::TensorPtr>> &input_tensors_ptr) {

  172.     input_ctrl_tensors_ = input_tensors_ptr;

  173.   }

  174.   // get input_tensors pointer of control parameter

  175.   std::shared_ptr<std::vector<tensor::TensorPtr>> input_ctrl_tensors() const { return input_ctrl_tensors_; }

  176.   // get parent kernel graph

  177.   std::weak_ptr<KernelGraph> parent_graph() const { return parent_graph_; }

  178.   // set parent kernel graph

  179.   void set_parent_graph(const std::weak_ptr<KernelGraph> &parent_graph) { parent_graph_ = parent_graph; }

  180.   // find anf node in graph

  181.   std::vector<CNodePtr> FindNodeByPrimitive(const PrimitivePtr &primitive) const;

  182.   std::vector<CNodePtr> FindNodeByPrimitive(const std::vector<PrimitivePtr> &primitive_list) const;

  183.   // used to dump ir

  184.   std::string ToString() const override;

  185. 

  186.   void set_start_label(const CNodePtr &start_label) { start_label_ = start_label; }

  187.   CNodePtr get_start_label() { return start_label_; }

  188.   void set_end_goto(const CNodePtr &end_goto) { end_goto_ = end_goto; }

  189.   CNodePtr get_end_goto() { return end_goto_; }

  190.   void PrintGraphExecuteOrder() const;

  191.   const std::map<std::string, std::pair<AnfNodePtr, int>> &summary_nodes() const { return summary_nodes_; }

  192.   void set_summary_nodes(const std::map<std::string, std::pair<AnfNodePtr, int>> &nodes) { summary_nodes_ = nodes; }

  193.   void AddInternalOutput(const AnfNodePtr &front_node, const AnfNodePtr &node, int output_idx = 0,

  194.                          bool unique_target = false);

  195.   void ReplaceInternalOutput(const AnfNodePtr &node, const AnfNodePtr &new_node, int src_output_idx = -1,

  196.                              int dst_output_idx = -1);

  197.   AnfNodePtr GetInternalOutputByFrontNode(const AnfNodePtr &front_node) const;

  198.   bool IsInternalOutput(const AnfNodePtr &node, int output_idx = -1) const;

  199.   bool IsUniqueTargetInternalOutput(const AnfNodePtr &node, int output_idx) const;

  200.   void AddInternalOutputTensor(const AnfNodePtr &node, int output_idx, const tensor::TensorPtr &tensor);

  201.   tensor::TensorPtr GetInternalOutputTensor(const AnfNodePtr &node, int output_idx);

  202. 

  203.   uint32_t current_epoch() const { return current_epoch_; }

  204.   void set_current_epoch(uint32_t epoch) { current_epoch_ = epoch; }

  205.   void UpdateChildGraphOrder();

  206.   const std::vector<AnfNodePtr> &child_graph_result() const { return child_graph_result_; }

  207.   void AddChildGraphResult(const AnfNodePtr &parameter) { child_graph_result_.push_back(parameter); }

  208.   void set_child_graph_result(const std::vector<AnfNodePtr> &child_graph_result) {

  209.     child_graph_result_ = child_graph_result;

  210.   }

  211. 

  212.   void InsertTupleParameterToMakeTupleMap(const AnfNodePtr &param, const AnfNodePtr &make_tuple) {

  213.     if (tuple_parameter_to_make_tuple_map_.find(param) != tuple_parameter_to_make_tuple_map_.end()) {

  214.       return;

  215.     }

  216.     tuple_parameter_to_make_tuple_map_[param] = make_tuple;

  217.   }

  218.   AnfNodePtr FindTupleParameterToMakeTupleMap(const AnfNodePtr &param) {

  219.     if (tuple_parameter_to_make_tuple_map_.find(param) != tuple_parameter_to_make_tuple_map_.end()) {

  220.       return tuple_parameter_to_make_tuple_map_[param];

  221.     } else {

  222.       return nullptr;

  223.     }

  224.   }

  225.   void RemoveNodeFromGraph(const AnfNodePtr &node);

  226.   // Add Param which pass callback point

  227.   ParameterPtr AddExtraParamAndTensor(std::string param_name, int32_t value);

  228.   const std::vector<std::pair<ParameterPtr, tensor::TensorPtr>> GetExtraParamAndTensor() { return extra_param_tensor_; }

  229.   void UpdateGraphDynamicAttr();

  230.   bool is_dynamic_shape() const { return is_dynamic_shape_; }

  231.   void SetOptimizerFlag();

  232.   void SetInputNodes();

  233.   const std::vector<AnfNodePtr> &input_nodes() const { return input_nodes_; }

  234.   bool has_optimizer() const { return has_optimizer_; }

  235.   // handle graph dependency

  236.   void AddPreGraph(const std::shared_ptr<session::KernelGraph> &graph) {

  237.     if (graph != nullptr) {

  238.       pre_graphs_[graph->graph_id()] = graph;

  239.     }

  240.   }

  241.   void AddPostGraph(const std::shared_ptr<session::KernelGraph> &graph) {

  242.     if (graph != nullptr) {

  243.       post_graphs_[graph->graph_id()] = graph;

  244.     }

  245.   }

  246. 

  247.   bool IsPreGraphFinished() { return pre_graphs_.size() == pre_graph_finished_count_; }

  248.   bool IsPostGraphFinished() {

  249.     if (first_step_) {

  250.       return true;

  251.     }

  252.     return post_graphs_.size() == post_graph_finished_count_;

  253.   }

  254.   void IncPreGraphFinishedCount() { pre_graph_finished_count_++; }

  255.   void IncPostGraphFinishedCount() { post_graph_finished_count_++; }

  256.   void ResetGraphRunningStatus() {

  257.     first_step_ = false;

  258.     post_graph_finished_count_ = 0;

  259.     pre_graph_finished_count_ = 0;

  260.   }

  261.   void OnRunGraphFinished() {

  262.     for (auto post_graph : post_graphs_) {

  263.       auto post_graph_ptr = post_graph.second.lock();

  264.       if (post_graph_ptr != nullptr) {

  265.         post_graph_ptr->IncPreGraphFinishedCount();

  266.       }

  267.     }

  268.     for (auto pre_graph : pre_graphs_) {

  269.       auto pre_graph_ptr = pre_graph.second.lock();

  270.       if (pre_graph_ptr != nullptr) {

  271.         pre_graph_ptr->IncPostGraphFinishedCount();

  272.       }

  273.     }

  274.   }

  275.   // end of handle graph dependency

  276. 

  277.   uint32_t label_num() const { return label_num_; }

  278.   void set_label_num(uint32_t num) { label_num_ = num; }

  279. 

  280.  private:

  281.   // remove value node form graph

  282.   bool RemoveValueNodeFromGraph(const ValueNodePtr &value_node);

  283.   void SetKernelInfoForNode(const AnfNodePtr &node) const;

  284.   void ResetInFormat(const AnfNodePtr &node, const std::string &format) const;

  285.   AnfNodePtr MakeValueNode(const AnfNodePtr &node);

  286.   void VisitNodeDescendants(const AnfNodePtr &node, std::queue<AnfNodePtr> *visit_queue,

  287.                             std::unordered_set<AnfNodePtr> *visited_nodes, bool comm_first = true);

  288.   // update node edge list

  289.   void UpdateNodeEdgeList(std::queue<AnfNodePtr> *seed_nodes);

  290.   // add node depend edge by data edge or control depend

  291.   void AddDependEdge(const AnfNodePtr &node, const AnfNodePtr &input, size_t depend_edge_num);

  292.   void UpdateNodeInputOutputEdges(const std::vector<AnfNodePtr> &real_prior_nodes,

  293.                                   const std::vector<AnfNodePtr> &real_depend_nodes);

  294.   // handle control depend

  295.   std::vector<AnfNodePtr> GetOutputNodes(const AnfNodePtr &node);

  296.   bool HandleControlDependNode(const AnfNodePtr &node, std::queue<AnfNodePtr> *que,

  297.                                std::unordered_set<AnfNodePtr> *visited_nodes);

  298.   void UpdateControlDependRelations(const std::vector<AnfNodePtr> &depends);

  299.   AnfNodePtr TransValueNodeTuple(const AbstractBasePtr abstract, const ValuePtr &value);

  300.   AnfNodePtr TransParameterTuple(const AbstractBasePtr &abstract);

  301.   AnfNodePtr TransCNodeTuple(const CNodePtr &node);

  302.   AnfNodePtr CreatTupleGetItemNode(const AnfNodePtr &node, size_t output_idx);

  303.   std::vector<CNodePtr> SortStartLabelAndEndGoto();

  304.   // checkout whether loop exist in graph

  305.   void CheckLoop();

  306.   uint32_t GetLoopNum(std::map<AnfNodePtr, size_t> none_zero_nodes);

  307.   void GetLoopNodesByDFS(AnfNodePtr node, uint32_t *loop_num);

  308. 

  309.   // members

  310.   std::shared_ptr<std::vector<AnfNodePtr>> inputs_;

  311.   std::vector<AnfNodePtr> child_graph_result_;

  312.   std::vector<CNodePtr> execution_order_;

  313.   // extra params and tensors for control flow

  314.   std::vector<std::pair<ParameterPtr, tensor::TensorPtr>> extra_param_tensor_;

  315.   uint32_t graph_id_;

  316.   uint32_t stream_distinction_label_;

  317. 

  318.   // record map bettween front anf and backend anf,use two map implement bidirectional map

  319.   std::unordered_map<AnfNodePtr, AnfNodePtr> front_backend_anf_map_;

  320.   std::unordered_map<AnfNodePtr, AnfNodePtr> backend_front_anf_map_;

  321.   // there may be a tensor from ME backend ,a value ndoe will be create according the tensor,map record

  322.   std::unordered_map<tensor::TensorPtr, ValueNodePtr> tensor_to_value_node_map_;

  323.   // include all value nodes

  324.   std::unordered_set<ValueNodePtr> graph_value_nodes_;

  325.   std::unordered_map<AnfNodePtr, size_t> node_input_num_;

  326.   std::unordered_map<AnfNodePtr, std::vector<std::pair<AnfNodePtr, size_t>>> node_input_edges_;

  327.   // record map between ref final output anf with index and ref origin input with index

  328.   std::map<AnfWithOutIndex, AnfWithOutIndex> ref_out_in_map_;

  329.   std::unordered_map<AnfNodePtr, std::vector<std::pair<AnfNodePtr, size_t>>> node_output_edges_;

  330.   std::map<std::string, std::pair<AnfNodePtr, int>> summary_nodes_;

  331.   // graph needn't execute

  332.   bool executable_{false};

  333.   // exist summary node in graph

  334.   bool summary_node_exist_{false};

  335.   // valid inputs

  336.   std::vector<bool> valid_inputs_;

  337. 

  338.   // child graph execute order in parent graph

  339.   std::vector<std::weak_ptr<KernelGraph>> child_graph_order_;

  340. 

  341.   // input_tensors of control parameter

  342.   std::shared_ptr<std::vector<tensor::TensorPtr>> input_ctrl_tensors_;

  343. 

  344.   // parameter graph

  345.   std::weak_ptr<KernelGraph> parent_graph_;

  346. 

  347.   CNodePtr start_label_;

  348.   CNodePtr end_goto_;

  349.   std::unordered_map<AnfNodePtr, AnfNodePtr> front_to_internal_outputs_map_;

  350.   std::unordered_map<AnfNodePtr, std::unordered_map<int, std::pair<AnfNodePtr, bool>>> internal_outputs_to_front_map_;

  351.   std::unordered_map<AnfNodePtr, std::unordered_map<int, tensor::TensorPtr>> internal_outputs_tensor_map_;

  352.   uint32_t current_epoch_;

  353.   std::unordered_map<AnfNodePtr, AnfNodePtr> tuple_parameter_to_make_tuple_map_;

  354.   std::set<AnfNodePtr> visited_nodes_;

  355.   std::map<AnfNodePtr, AnfNodePtr> edge_to_;

  356.   std::stack<AnfNodePtr> loop_nodes_;

  357.   std::vector<AnfNodePtr> input_nodes_;

  358.   std::unordered_map<uint32_t, std::weak_ptr<session::KernelGraph>> pre_graphs_;

  359.   std::unordered_map<uint32_t, std::weak_ptr<session::KernelGraph>> post_graphs_;

  360.   std::atomic<size_t> pre_graph_finished_count_{0};

  361.   std::atomic<size_t> post_graph_finished_count_{0};

  362.   bool first_step_{true};

  363.   bool has_optimizer_{false};

  364.   bool is_dynamic_shape_{false};

  365. 

  366.   // Number of labels. This is also the 'batch_num' for DavinciModel,

  367.   // It should be 1 if no labels used for control flow.

  368.   uint32_t label_num_ = 1;

  369. };

  370. }  // namespace session

  371. using KernelGraphPtr = std::shared_ptr<session::KernelGraph>;

  372. }  // namespace mindspore

  373. #endif  // MINDSPORE_CCSRC_BACKEND_SESSION_KERNEL_GRAPH_H