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: ae3a9d2883
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ae3a9d2883'
${ noResults }
mindspore/mindspore/ccsrc/pipeline/pynative/pynative_execute.h

497 lines
25 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. 

  17. #ifndef MINDSPORE_CCSRC_PIPELINE_PYNATIVE_PYNATIVE_EXECUTE_H_

  18. #define MINDSPORE_CCSRC_PIPELINE_PYNATIVE_PYNATIVE_EXECUTE_H_

  19. 

  20. #include <utility>

  21. #include <vector>

  22. #include <string>

  23. #include <memory>

  24. #include <unordered_map>

  25. #include <unordered_set>

  26. #include <mutex>

  27. #include <stack>

  28. #include <set>

  29. #include <map>

  30. 

  31. #include "pybind11/pybind11.h"

  32. #include "pybind11/numpy.h"

  33. 

  34. #include "pybind_api/ir/base_ref_py.h"

  35. #include "pipeline/pynative/base.h"

  36. #include "utils/ms_context.h"

  37. #include "ir/anf.h"

  38. #include "pipeline/jit/resource.h"

  39. #include "frontend/operator/composite/composite.h"

  40. 

  41. namespace mindspore {

  42. namespace pynative {

  43. namespace py = pybind11;

  44. using ResourcePtr = std::shared_ptr<pipeline::Resource>;

  45. using GradOperationPtr = std::shared_ptr<prim::GradOperation>;

  46. 

  47. struct PrimAbsInfo {

  48.   abstract::AbstractBasePtr abs;

  49.   bool is_dynamic_shape = false;

  50.   std::unordered_map<std::string, ValuePtr> attrs;

  51. };

  52. 

  53. using AbstractListMap = std::unordered_map<abstract::AbstractBasePtrList, PrimAbsInfo,

  54.                                            abstract::AbstractBasePtrListHasher, abstract::AbstractBasePtrListEqual>;

  55. using OpIndexWithTensorId = std::unordered_map<std::string, std::vector<std::string>>;

  56. using TensorIdWithTensor = std::unordered_map<std::string, std::vector<tensor::TensorPtr>>;

  57. 

  58. py::object RunOp(const py::args &args);

  59. 

  60. void ClearPyNativeSession();

  61. 

  62. struct GraphInfo {

  63.   std::string cell_id;

  64.   AnfNodePtr output;

  65.   OrderedMap<std::string, ParameterPtr> params;  // hold input parameters and cell weights

  66.   std::unordered_map<std::string, std::pair<AnfNodePtr, std::vector<int64_t>>> node_map;

  67.   std::vector<std::string> objects;

  68.   GraphInfo() = default;

  69.   explicit GraphInfo(std::string id) : cell_id(std::move((id))) {}

  70. };

  71. using GraphInfoPtr = std::shared_ptr<GraphInfo>;

  72. 

  73. class CellInfo {

  74.  public:

  75.   CellInfo() = default;

  76.   ~CellInfo() = default;

  77.   CellInfo(bool custom_bprop, bool has_dynamic, FuncGraphPtr foward_graph, std::string cellid, std::string bprop_id)

  78.       : is_custom_bprop_(custom_bprop),

  79.         is_dynamic_(has_dynamic),

  80.         fg_(std::move(foward_graph)),

  81.         cell_id_(std::move(cellid)),

  82.         bprop_cell_id_(std::move(bprop_id)) {}

  83. 

  84.   bool is_custom_bprop() const { return is_custom_bprop_; }

  85.   void set_is_custom_bprop(bool is_custom_bprop) { is_custom_bprop_ = is_custom_bprop; }

  86.   bool is_dynamic() const { return is_dynamic_; }

  87.   void set_is_dynamic(bool is_dynamic) { is_dynamic_ = is_dynamic; }

  88.   size_t call_times() const { return call_times_; }

  89.   void set_call_times(size_t call_times) { call_times_ = call_times; }

  90.   FuncGraphPtr fg() const { return fg_; }

  91.   void set_fg(FuncGraphPtr fg) { fg_ = std::move(fg); }

  92.   std::string &cell_id() { return cell_id_; }

  93.   void set_cell_id(std::string cell_id) { cell_id_ = std::move(cell_id); }

  94.   std::string &bprop_cell_id() { return bprop_cell_id_; }

  95.   std::vector<std::string> &cell_ops_info() { return cell_ops_info_; }

  96. 

  97.  private:

  98.   bool is_custom_bprop_{false};  // Custom bprop

  99.   bool is_dynamic_{false};       // Set by has_dynamic_cell

  100.   size_t call_times_{0};

  101.   FuncGraphPtr fg_{nullptr};  // Forward graph

  102.   std::string cell_id_;

  103.   std::string bprop_cell_id_;

  104.   std::vector<std::string> cell_ops_info_;  // All ops info

  105. };

  106. using CellInfoPtr = std::shared_ptr<CellInfo>;

  107. 

  108. class TopCellInfo {

  109.  public:

  110.   TopCellInfo() = default;

  111.   ~TopCellInfo() = default;

  112.   TopCellInfo(bool topest, ResourcePtr r, FuncGraphPtr df, std::string cellid)

  113.       : is_topest_(topest), resource_(std::move(r)), df_builder_(std::move(df)), cell_id_(std::move(cellid)) {}

  114. 

  115.   bool is_grad() const { return is_grad_; }

  116.   void set_is_grad(bool is_grad) { is_grad_ = is_grad; }

  117.   bool is_topest() const { return is_topest_; }

  118.   bool vm_compiled() const { return vm_compiled_; }

  119.   void set_vm_compiled(bool vm_compiled) { vm_compiled_ = vm_compiled; }

  120.   bool need_grad() const { return need_grad_; }

  121.   void set_need_grad(bool need_grad) { need_grad_ = need_grad; }

  122.   bool has_dynamic_cell() const { return has_dynamic_cell_; }

  123.   bool is_real_dynamic() const { return is_real_dynamic_; }

  124.   void set_is_real_dynamic(bool is_real_dynamic) { is_real_dynamic_ = is_real_dynamic; }

  125.   bool forward_already_run() const { return forward_already_run_; }

  126.   void set_forward_already_run(bool set_forward_already_run) { forward_already_run_ = set_forward_already_run; }

  127.   ResourcePtr resource() { return resource_; }

  128.   FuncGraphPtr df_builder() { return df_builder_; }

  129.   std::string &cell_id() { return cell_id_; }

  130.   std::string &sens_id() { return sens_id_; }

  131.   void set_sens_id(std::string sens_id) { sens_id_ = std::move(sens_id); }

  132.   std::string &weights_id() { return weights_id_; }

  133.   void set_weights_id(std::string weights_id) { weights_id_ = std::move(weights_id); }

  134.   std::string &input_args_id() { return input_args_id_; }

  135.   void set_input_args_id(std::string input_args_id) { input_args_id_ = std::move(input_args_id); }

  136.   std::vector<CellInfoPtr> &cell_graph_list() { return cell_graph_list_; }

  137.   void set_cell_graph_list(const std::vector<CellInfoPtr> &cell_graph_list) { cell_graph_list_ = cell_graph_list; }

  138.   OrderedMap<FuncGraphPtr, GraphInfoPtr> &graph_info_map() { return graph_info_map_; }

  139.   void set_graph_info_map(const OrderedMap<FuncGraphPtr, GraphInfoPtr> &graph_info_map) {

  140.     graph_info_map_ = graph_info_map;

  141.   }

  142.   void clear() {

  143.     cell_graph_list_.clear();

  144.     graph_info_map_.clear();

  145.   }

  146. 

  147.  private:

  148.   bool is_grad_{false};  // Derivative is calculated

  149.   bool is_topest_{false};

  150.   bool vm_compiled_{false};

  151.   bool need_grad_{true};

  152.   bool has_dynamic_cell_{false};

  153.   bool is_real_dynamic_{false};

  154.   bool forward_already_run_{false};

  155.   ResourcePtr resource_{nullptr};

  156.   FuncGraphPtr df_builder_{nullptr};

  157.   std::string cell_id_;

  158.   std::string sens_id_;

  159.   std::string weights_id_;

  160.   std::string input_args_id_;

  161.   std::vector<CellInfoPtr> cell_graph_list_;

  162.   OrderedMap<FuncGraphPtr, GraphInfoPtr> graph_info_map_;

  163. };

  164. using TopCellInfoPtr = std::shared_ptr<TopCellInfo>;

  165. 

  166. class DynamicAnalysis;

  167. using DynamicAnalysisPtr = std::shared_ptr<DynamicAnalysis>;

  168. 

  169. class ForwardExecutor;

  170. using ForwardExecutorPtr = std::shared_ptr<ForwardExecutor>;

  171. using ForwardExecutorWeakPtr = std::weak_ptr<ForwardExecutor>;

  172. 

  173. class GradExecutor;

  174. using GradExecutorPtr = std::shared_ptr<GradExecutor>;

  175. using GradExecutorWeakPtr = std::weak_ptr<GradExecutor>;

  176. 

  177. class DynamicAnalysis {

  178.  public:

  179.   DynamicAnalysis() = default;

  180.   ~DynamicAnalysis() = default;

  181. 

  182.   // Check cell struct

  183.   bool IsDynamicCell(const py::object &cell);

  184. 

  185.  private:

  186.   std::string GetCellInfo(const py::object &cell);

  187.   void ParseInputArgs(const std::shared_ptr<parse::ParseAst> &ast, const py::object &fn_node);

  188.   bool ParseBodyContext(const std::shared_ptr<parse::ParseAst> &ast, const py::object &fn_node,

  189.                         const std::vector<std::string> &compare_prim = {});

  190.   bool ParseIfWhileExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node);

  191.   bool ParseAssignExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node);

  192.   bool ParseAugAssignExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node,

  193.                               const std::vector<std::string> &compare_prim = {});

  194.   bool ParseForExprNode(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node);

  195.   std::string ParseNodeName(const std::shared_ptr<parse::ParseAst> &ast, const py::object &node,

  196.                             parse::AstMainType type);

  197. 

  198.   std::unordered_set<std::string> cell_input_args_;

  199. };

  200. 

  201. class GradExecutor {

  202.  public:

  203.   GradExecutor() = default;

  204.   ~GradExecutor() = default;

  205.   explicit GradExecutor(const ForwardExecutorPtr &forward_executor = nullptr)

  206.       : forward_executor_(ForwardExecutorWeakPtr(forward_executor)) {}

  207. 

  208.   std::function<void(py::object *, const py::object &, const py::args &)> InitGraph = [this](auto &&PH1, auto &&PH2,

  209.                                                                                              auto &&PH3) {

  210.     NewGraphInner(std::forward<decltype(PH1)>(PH1), std::forward<decltype(PH2)>(PH2), std::forward<decltype(PH3)>(PH3));

  211.   };

  212.   std::function<void(py::object *, const py::object &, const py::object &, const py::args &)> LinkGraph =

  213.     [this](auto &&PH1, auto &&PH2, auto &&PH3, auto &&PH4) {

  214.       EndGraphInner(std::forward<decltype(PH1)>(PH1), std::forward<decltype(PH2)>(PH2),

  215.                     std::forward<decltype(PH3)>(PH3), std::forward<decltype(PH4)>(PH4));

  216.     };

  217.   std::function<void(py::object *, const GradOperationPtr &, const py::object &, const py::object &, const py::args &)>

  218.     GradGraph = [this](auto &&PH1, auto &&PH2, auto &&PH3, auto &&PH4, auto &&PH5) {

  219.       GradNetInner(std::forward<decltype(PH1)>(PH1), std::forward<decltype(PH2)>(PH2), std::forward<decltype(PH3)>(PH3),

  220.                    std::forward<decltype(PH4)>(PH4), std::forward<decltype(PH5)>(PH5));

  221.     };

  222.   std::function<void(py::object *, const py::object &, const py::tuple &, const py::object &)> RunGraph =

  223.     [this](auto &&PH1, auto &&PH2, auto &&PH3, auto &&PH4) {

  224.       RunGradGraph(std::forward<decltype(PH1)>(PH1), std::forward<decltype(PH2)>(PH2), std::forward<decltype(PH3)>(PH3),

  225.                    std::forward<decltype(PH4)>(PH4));

  226.     };

  227. 

  228.   FuncGraphPtr curr_g() const;

  229.   TopCellInfoPtr top_cell() const;

  230.   bool TopCellIsDynamic();

  231.   void set_top_cell(TopCellInfoPtr top_cell) { top_cell_ = std::move(top_cell); }

  232.   bool grad_flag() const { return grad_flag_; }

  233.   void set_grad_flag(bool flag) { grad_flag_ = flag; }

  234.   bool in_grad_process() const { return in_grad_process_; }

  235.   std::string top_cell_id() { return top_cell()->cell_id(); }

  236.   AnfNodePtr GetInput(const py::object &obj, bool op_mask);

  237.   std::string GetCellId(const py::object &obj, const py::args &args);

  238.   TopCellInfoPtr GetTopCell(const string &cell_id, bool find_nearest = false);

  239.   void SaveOutputNodeMap(const std::string &obj_id, const py::object &out_real, const AnfNodePtr &cnode);

  240.   void SaveAllResult(const OpExecInfoPtr &op_exec_info, const AnfNodePtr &node, const py::object &out_real);

  241.   py::object CheckGraph(const py::object &cell, const py::args &args);

  242.   void RunGradGraph(py::object *ret, const py::object &cell, const py::tuple &args, const py::object &phase);

  243.   bool need_construct_graph() const { return !graph_stack_.empty() && grad_flag_; }

  244.   void set_dynamic_analysis(DynamicAnalysisPtr dynamic_analysis) { dynamic_analysis_ = std::move(dynamic_analysis); }

  245.   std::stack<FuncGraphPtr> &graph_stack() { return graph_stack_; }

  246.   std::vector<TopCellInfoPtr> &top_cell_list() { return top_cell_list_; }

  247.   bool need_replace_forward() const { return need_replace_forward_; }

  248.   std::stack<std::string> &cell_op_info_stack() { return cell_op_info_stack_; }

  249.   std::unordered_map<std::string, size_t> &op_index_map() { return op_index_map_; }

  250.   std::unordered_map<std::string, std::string> &obj_to_forward_id() { return obj_to_forward_id_; }

  251.   void ClearGrad(const py::object &cell, const py::args &args);

  252.   void ClearRes();

  253.   void ClearCellRes(const std::string &cell_id = "");

  254. 

  255.  private:

  256.   ForwardExecutorPtr forward() const;

  257.   DynamicAnalysisPtr dynamic_analysis() const;

  258.   bool grad_running() const { return grad_is_running_; }

  259.   void set_grad_runing(bool grad_runing) { grad_is_running_ = grad_runing; }

  260.   void set_need_replace_forward(bool need_replace_forward) { need_replace_forward_ = need_replace_forward; }

  261. 

  262.   // Higher derivative

  263.   bool IsNestedGrad() const;

  264.   void AddNestedGradOrder() { ++grad_order_; }

  265.   void SubNestedGradOrder();

  266.   void ReplaceGraphParams(const FuncGraphPtr &df_builder, const FuncGraphPtr &forward_graph,

  267.                           const std::string &cell_id);

  268.   void SetNestedTopGraph(const py::object &cell, const py::args &args, const std::string &cell_id);

  269.   void MakeNestedCnode(const std::string &cell_id, const py::args &args, const ResourcePtr &resource,

  270.                        const py::object &out, bool has_sens);

  271.   void RecoverGraphParams(const FuncGraphPtr &newfg, const std::string &cell_id, std::vector<AnfNodePtr> *inputs);

  272.   bool MakeBpropNestedCnode(const py::object &cell, const py::object &out, const std::string &cell_id);

  273. 

  274.   // Dynamic

  275.   bool CheckDynamicCell(const std::string &cell_id);

  276.   bool CheckRealDynamicCell(const std::string &cell_id);

  277.   void ClearDynamicTopRes(const std::string &cell_id);

  278. 

  279.   void PushCurrentGraphToStack();

  280.   void PopGraphStack();

  281.   void PushCurrentCellOpInfoToStack();

  282.   void PopCurrentCellOpInfoFromStack();

  283.   std::string GetCellOpInfo();

  284.   void ReplaceCellOpInfoByCellId(const std::string &cell_id);

  285. 

  286.   FuncGraphPtr GetDfbuilder(const std::string &cell_id = "");

  287.   ResourcePtr GetResource(const std::string &cell_id = "");

  288.   bool IsFirstGradStep();

  289.   bool IsTopGraph(const std::string &cell_id);

  290.   bool IsTopestGraph(const std::string &cell_id);

  291.   bool IsBpropGraph(const std::string &cell_id);

  292.   bool IsGradBefore(const std::string &cell_id);

  293.   bool CheckCellGraph(const std::string &cell_id);

  294.   bool UpdateBpropCellGraph(const py::object &cell, const FuncGraphPtr &g, const std::string &cell_id, bool need_cloned,

  295.                             bool is_grad);

  296.   void UpdateCellGraph(const py::object &cell, const FuncGraphPtr &g, const std::string &cell_id,

  297.                        bool need_cloned = false, bool is_grad = false);

  298.   bool CheckCellChanged(const std::string &cell_id);

  299.   void UpdateTopCellInfo(const std::string &cell_id, bool vm_compiled);

  300.   void DumpGraphIR(const std::string &filename, const FuncGraphPtr &graph);

  301.   void NewGraphInner(py::object *ret, const py::object &cell, const py::args &args);

  302.   void MakeNewTopGraph(const string &cell_id, const py::args &args);

  303.   void EndGraphInner(py::object *ret, const py::object &cell, const py::object &out, const py::args &args);

  304.   void EndGraphByOutId(const py::object &cell, const std::string &cell_id, const py::object &out,

  305.                        const std::string &out_id, const py::args &args);

  306.   bool EndBpropGraph(const string &cell_id);

  307.   FuncGraphPtr MakeGradGraph(const py::object &cell, const FuncGraphPtr &g, const ResourcePtr &r,

  308.                              const std::string &cell_id, const py::args &args);

  309.   std::string GetGradCellId(bool has_sens, const py::object &cell, const py::args &args, py::object *forward_args,

  310.                             py::object *sens = nullptr);

  311.   void GradNetInner(py::object *ret, const GradOperationPtr &grad, const py::object &cell, const py::object &weights,

  312.                     const py::args &args);

  313.   void SetTopCellTensorId(const std::string &cell_id);

  314.   bool CheckGradParamsChanged(const std::string &cell_id, const py::object &weights, const py::object &sens);

  315.   void SetGradGraphParams(const FuncGraphPtr &df_builder, const ResourcePtr &resource, size_t size);

  316.   void SetGradGraph(const FuncGraphPtr &g, const GradOperationPtr &grad_op, const std::vector<AnfNodePtr> &weights,

  317.                     size_t arg_size, const std::string &cell_id);

  318.   std::vector<AnfNodePtr> GetWeightsArgs(const py::object &weights, const FuncGraphPtr &df_builder);

  319.   abstract::AbstractBasePtrList GetArgsSpec(const py::args &args, const FuncGraphPtr &df_builder);

  320.   void ClearUselessRes(const FuncGraphPtr &df_builder, const py::object &cell, const std::string &cell_id);

  321.   void SetTupleItemArgsToGraphInfoMap(const FuncGraphPtr &g, const py::object &id, const AnfNodePtr &node,

  322.                                       const std::vector<int64_t> &index_sequence, bool is_param = false);

  323.   AnfNodePtr GetObjNode(const py::object &obj, const std::string &obj_id);

  324.   AnfNodePtr MakeValueNode(const py::object &obj, const std::string &obj_id);

  325. 

  326.   // Memory clean between steps

  327.   void ClearResidualRes(const std::string &cell_id);

  328.   void ClearCnodeRes(const AnfNodePtr &node);

  329.   void CleanPreMemoryInValueNode();

  330.   void SaveTensorsInValueNode(const ResourcePtr &resource);

  331.   void SaveAllValueNodeTensors(const FuncGraphPtr &graph);

  332. 

  333.   void SetPyObjInGraphInfoMap(const FuncGraphPtr &g, const std::string &obj) {

  334.     top_cell()->graph_info_map()[g]->objects.push_back(obj);

  335.   }

  336.   void SetTupleArgsToGraphInfoMap(const FuncGraphPtr &g, const py::object &args, const AnfNodePtr &node,

  337.                                   bool is_param = false);

  338.   void SetParamNodeMapInGraphInfoMap(const FuncGraphPtr &g, const std::string &id, const ParameterPtr &param) {

  339.     top_cell()->graph_info_map()[g]->params[id] = param;

  340.   }

  341.   void SetNodeMapInGraphInfoMap(const FuncGraphPtr &g, const std::string &id, const AnfNodePtr &node,

  342.                                 int64_t index = -1) {

  343.     top_cell()->graph_info_map()[g]->node_map[id] = std::make_pair(node, std::vector<int64_t>{index});

  344.   }

  345.   void SetNodeMapInGraphInfoMap(const FuncGraphPtr &g, const std::string &id, const AnfNodePtr &node,

  346.                                 const std::vector<int64_t> &index) {

  347.     top_cell()->graph_info_map()[g]->node_map[id] = std::make_pair(node, index);

  348.   }

  349. 

  350.  private:

  351.   size_t grad_order_{0};

  352.   bool grad_flag_{false};

  353.   bool in_bprop_process_{false};

  354.   bool in_grad_process_{false};

  355.   bool has_dynamic_cell_{false};

  356.   bool need_replace_forward_{true};

  357.   bool grad_is_running_{false};

  358.   FuncGraphPtr curr_g_{nullptr};

  359.   // For clear pre top res

  360.   TopCellInfoPtr pre_top_cell_{nullptr};

  361.   TopCellInfoPtr top_cell_{nullptr};

  362.   std::unordered_map<std::string, size_t> op_index_map_;

  363.   std::unordered_map<FuncGraphPtr, std::vector<std::pair<ParameterPtr, ParameterPtr>>> replace_weights_map_;

  364.   std::unordered_set<tensor::TensorPtr> all_value_node_tensors_;

  365.   std::unordered_map<std::string, std::string> obj_to_forward_id_;

  366. 

  367.   // Records forwrad graph, the bottom is top graph

  368.   std::stack<FuncGraphPtr> graph_stack_;

  369.   // Records op info of every cell, the bottom is op info of top cell

  370.   std::stack<std::string> cell_op_info_stack_;

  371. 

  372.   // Use vector for keep order

  373.   std::vector<TopCellInfoPtr> top_cell_list_;

  374.   ForwardExecutorWeakPtr forward_executor_;

  375.   DynamicAnalysisPtr dynamic_analysis_;

  376. };

  377. 

  378. class ForwardExecutor {

  379.  public:

  380.   ForwardExecutor() = default;

  381.   ~ForwardExecutor() = default;

  382. 

  383.   std::function<void(py::object *, const OpExecInfoPtr &)> RunOpS = [this](auto &&PH1, auto &&PH2) {

  384.     RunOpInner(std::forward<decltype(PH1)>(PH1), std::forward<decltype(PH2)>(PH2));

  385.   };

  386. 

  387.   void RunOpInner(py::object *ret, const OpExecInfoPtr &op_exec_info);

  388.   OpExecInfoPtr GenerateOpExecInfo(const py::args &args);

  389.   void set_grad_executor(const GradExecutorPtr &grad_executor) { grad_executor_ = GradExecutorWeakPtr(grad_executor); }

  390.   std::unordered_map<std::string, abstract::AbstractBasePtr> &node_abs_map() { return node_abs_map_; }

  391.   std::unordered_map<std::string, OpIndexWithTensorId> &cell_op_index_with_tensor_id() {

  392.     return cell_op_index_with_tensor_id_;

  393.   }

  394.   std::unordered_map<std::string, TensorIdWithTensor> &cell_tensor_id_with_tensor() {

  395.     return cell_tensor_id_with_tensor_;

  396.   }

  397.   void ClearRes();

  398. 

  399.  private:

  400.   GradExecutorPtr grad() const;

  401.   MsBackendPolicy InitEnv(const OpExecInfoPtr &op_exec_info);

  402.   py::tuple RunOpWithInitBackendPolicy(const OpExecInfoPtr &op_exec_info);

  403.   py::object RunOpInVM(const OpExecInfoPtr &op_exec_info, PynativeStatusCode *status);

  404.   py::object RunOpInMs(const OpExecInfoPtr &op_exec_info, PynativeStatusCode *status);

  405.   py::object RunOpWithBackendPolicy(MsBackendPolicy backend_policy, const OpExecInfoPtr &op_exec_info,

  406.                                     PynativeStatusCode *status);

  407.   AnfNodePtr MakeCNode(const OpExecInfoPtr &op_exec_info, std::vector<int64_t> *op_masks,

  408.                        abstract::AbstractBasePtrList *args_spec_list);

  409.   void GetArgsSpec(const OpExecInfoPtr &op_exec_info, std::vector<int64_t> *op_masks, std::vector<AnfNodePtr> *inputs,

  410.                    abstract::AbstractBasePtrList *args_spec_list);

  411.   abstract::AbstractBasePtr CheckConstValue(const PrimitivePyPtr &prim, const py::object &obj,

  412.                                             const abstract::AbstractBasePtr &abs, const std::string &id, size_t index);

  413.   void GetOpOutputAbstract(const OpExecInfoPtr &op_exec_info, const abstract::AbstractBasePtrList &args_spec_list,

  414.                            bool *is_find);

  415.   // Update the abstract and device address info of value node and tensors in bprop graph

  416.   void UpdateAbstractAndDeviceAddress(const OpExecInfoPtr &op_exec_info, const py::object &out_real);

  417. 

  418.   // Mix precision

  419.   void RunParameterAutoMixPrecisionCast(const OpExecInfoPtr &op_exec_info);

  420.   py::object DoParamMixPrecisionCast(bool *is_cast, const py::object &obj, const std::string &op_name, size_t index);

  421.   py::object DoParamMixPrecisionCastTuple(bool *is_cast, const py::tuple &tuple, const std::string &op_name,

  422.                                           size_t index);

  423.   py::object DoAutoCast(const py::object &arg, const TypeId &type_id, const std::string &op_name, size_t index);

  424.   void DoSignatrueCast(const PrimitivePyPtr &prim, const std::map<SignatureEnumDType, TypeId> &dst_type,

  425.                        const std::vector<SignatureEnumDType> &dtypes, const OpExecInfoPtr &op_exec_info);

  426. 

  427.  private:

  428.   GradExecutorWeakPtr grad_executor_;

  429.   std::unordered_map<std::string, AbstractListMap> prim_abs_list_;

  430.   std::unordered_map<std::string, abstract::AbstractBasePtr> node_abs_map_;

  431.   // Used for runop and replace forward result of grad graph

  432.   std::unordered_map<std::string, OpIndexWithTensorId> cell_op_index_with_tensor_id_;

  433.   std::unordered_map<std::string, TensorIdWithTensor> cell_tensor_id_with_tensor_;

  434. };

  435. 

  436. class PynativeExecutor : public std::enable_shared_from_this<PynativeExecutor> {

  437.  public:

  438.   static std::shared_ptr<PynativeExecutor> GetInstance() {

  439.     std::lock_guard<std::mutex> i_lock(instance_lock_);

  440.     if (executor_ == nullptr) {

  441.       executor_ = std::shared_ptr<PynativeExecutor>(new (std::nothrow) PynativeExecutor());

  442.       forward_executor_ = std::make_shared<ForwardExecutor>();

  443.       grad_executor_ = std::make_shared<GradExecutor>(forward_executor_);

  444.       grad_executor_->set_dynamic_analysis(std::make_shared<DynamicAnalysis>());

  445.       forward_executor_->set_grad_executor(grad_executor_);

  446.     }

  447.     return executor_;

  448.   }

  449.   ~PynativeExecutor() = default;

  450.   PynativeExecutor(const PynativeExecutor &) = delete;

  451.   PynativeExecutor &operator=(const PynativeExecutor &) = delete;

  452. 

  453.   void EnterConstruct(const py::object &cell);

  454.   void LeaveConstruct(const py::object &cell);

  455.   GradExecutorPtr grad_executor();

  456.   ForwardExecutorPtr forward_executor();

  457. 

  458.   void set_grad_flag(bool flag);

  459.   void NewGraph(const py::object &cell, const py::args &args);

  460.   void EndGraph(const py::object &cell, const py::object &out, const py::args &args);

  461.   void GradNet(const GradOperationPtr &grad, const py::object &cell, const py::object &weights, const py::args &args);

  462.   py::object CheckGraph(const py::object &cell, const py::args &args);

  463.   py::object CheckAlreadyRun(const py::object &cell, const py::args &args);

  464.   py::object Run(const py::object &cell, const py::tuple &args, const py::object &phase);

  465. 

  466.   // Used by graph clean

  467.   bool GetIsDynamicCell();

  468.   bool need_replace_forward() { return grad_executor()->need_replace_forward(); }

  469.   // Cell destruct will call

  470.   void ClearCell(const std::string &flag = "");

  471.   void ClearGrad(const py::object &cell, const py::args &args);

  472.   // Abnormal existed

  473.   void ClearRes();

  474.   // Sync stream

  475.   void Sync();

  476. 

  477.  private:

  478.   PynativeExecutor() = default;

  479. 

  480.   static std::shared_ptr<PynativeExecutor> executor_;

  481.   static std::mutex instance_lock_;

  482.   static ForwardExecutorPtr forward_executor_;

  483.   static GradExecutorPtr grad_executor_;

  484.   // The pointer of top python Cell object, which is always the network(inherit class Cell) ran in python test script,

  485.   // such as Resnet50(Cell),LeNet(Cell).This pointer is used to distinguish temporary primitives from global

  486.   // primitives to control memory release. Global primitives are always created in top cell's '__init__' function and

  487.   // temporary primitives are always created in other place.Temporary primitives will be released after executing top

  488.   // cell's 'construct' function but global primitives will not.

  489.   PyObject *py_top_cell_{nullptr};

  490. };

  491. 

  492. using PynativeExecutorPtr = std::shared_ptr<PynativeExecutor>;

  493. }  // namespace pynative

  494. }  // namespace mindspore

  495. 

  496. #endif  // MINDSPORE_CCSRC_PIPELINE_PYNATIVE_PYNATIVE_EXECUTE_H_