Pass FuseOps(int fuse_opt_level) {

 runtime::TypedPackedFunc<Function(Function, IRModule, PassContext)> pass_func = // Pass 的关键执行函数

     [=](Function f, IRModule m, PassContext pc) {

       bool link_params = false;

       Executor executor =

           m->GetAttr<Executor>(tvm::attr::kExecutor).value_or(NullValue<Executor>());

       link_params = executor.defined()

                         ? executor->attrs.GetAttr<Bool>("link-params").value_or(Bool(link_params))

                         : link_params;

       link_params = pc->GetConfig("relay.FuseOps.link_params", Bool(link_params)).value();

       int opt_level = fuse_opt_level == -1 ? pc->opt_level : fuse_opt_level;

       auto max_fuse_depth = pc->GetConfig("relay.FuseOps.max_depth", Integer(kMaxFusedOps));

       auto target = Target::Current();

       size_t max_function_args =

           (target.defined())

               ? target->GetAttr<Integer>("max_function_args", Integer(0)).value().IntValue()

               : 0;

       return Downcast<Function>(FuseOps(f, opt_level, max_fuse_depth.value().IntValue(),

                                         max_function_args, link_params, m));

     };

 return CreateFunctionPass(pass_func, 0, "FuseOps", {"InferType"});  // 返回 FunctionPass

}

Expr FuseOps(const Expr& expr, int fuse_opt_level, size_t max_fuse_depth, size_t max_function_args,

            bool link_params, const IRModule& module) {

 return FuseMutator(fuse_opt_level, max_fuse_depth, max_function_args, link_params)

     .Transform(expr);

}

// Run the transform

 Expr Transform(const Expr& body, int fuse_opt_level, size_t max_fuse_depth, bool link_params) {

   // setup the group map.

   auto graph = IndexedForwardGraphCreator::Create(&arena_, body);

   auto groups = GraphPartitioner(&arena_, fuse_opt_level, max_fuse_depth, max_function_args_)

                     .Partition(graph);

   for (size_t nid = 0; nid < graph.post_dfs_order.size(); ++nid) {

     ICHECK(graph.post_dfs_order[nid]->ref != nullptr);

     gmap_[graph.post_dfs_order[nid]->ref] = groups[nid];

   }

   // The following line can be used for debug.

   // this->DebugDumpGroup(body);

   return this->Mutate(body);

 }

// Creator of post dominator tree of the dataflow

class IndexedForwardGraphCreator : private ExprVisitor {

 public:

  static IndexedForwardGraph Create(support::Arena* arena, const Expr& body) {

    IndexedForwardGraphCreator creator(arena);

    return creator.Prepare(body);

  }

 private:

  explicit IndexedForwardGraphCreator(support::Arena* arena) : arena_(arena) {}

  IndexedForwardGraph Prepare(const Expr& body) { // 创建前序图结构

    this->Update(body, nullptr, kOpaque);  // 创建首个根节点

    this->VisitExpr(body);  // 遍历抽象语法树，逐个创建节点和边，构建前序图结构

    return std::move(graph_);

  }

   private:

  /*! \brief allocator of all the internal node object */

  support::Arena* arena_;

  // The output.

  IndexedForwardGraph graph_;  // Prepare 函数创建的图结构类

class IndexedForwardGraph {

 public:

  struct Edge {

    /*! \brief The corresponding node */

    Node* node{nullptr};

    /*! \brief The respective pattern of this op */

    OpPatternKind pattern{kOpaque};

  };

  /*! \brief A node in the graph. */

  struct Node {  // 

    /*! \brief weak reference to the corresponding edge. */

    const tvm::Object* ref{nullptr};

    /*! \brief The index of the node in topological order. */

    size_t index{0};

    /*! \brief Whether this node is referenced by external source */

    bool extern_ref{false};

    /*! \brief The general pattern in the node */

    OpPatternKind pattern{kOpaque};

    /*! \brief The outputs of the node. */

    LinkedList<Edge> outputs;

  };

  /*! \brief The node map that maps node to graph */

  std::unordered_map<const tvm::Object*, Node*> node_map;

  /*! \brief All the nodes in post DFS order */

  std::vector<Node*> post_dfs_order;

}

std::vector<GraphPartitioner::Group*> GraphPartitioner::Partition(

    const IndexedForwardGraph& graph) {

  this->InitGroups(graph);  // 每个节点初始化为一个 group

  if (opt_level_ == 0) return std::move(groups_);

  // get post dominator tree

  auto post_dom_tree = DominatorTree::PostDom(arena_, graph);  // 构建后支配树

  // run fusion algorithm.

  for (int phase = 0; phase < 3; ++phase) {  // 分三个阶段执行融合

    this->RunFuse(graph, post_dom_tree, phase);

  }

  return std::move(groups_);

}

void GraphPartitioner::MergeFromTo(Group* child, Group* parent) {

  child = child->FindRoot();

  parent = parent->FindRoot();

  if (child == parent) return;

  // update the number of nodes of the parent group

  parent->num_nodes += child->num_nodes;

  parent->args_num += child->args_num;

  child->parent = parent;    // 合并 group

  // update anchor ref and pattern

  if (child->anchor_ref != nullptr) {

    ICHECK(parent->anchor_ref == nullptr);

    parent->anchor_ref = child->anchor_ref;

    parent->pattern = CombinePattern(child->pattern, parent->pattern);

  }

}

// Transform calls.

  Expr Rewrite_(const CallNode* call, const Expr& post) {

    if (call->op.as<OpNode>()) {

      static auto fnoncomputational = Op::GetAttrMap<TNonComputational>("TNonComputational");

      static auto fqnncanonicalize = Op::GetAttrMap<FTVMLegalize>("FTVMQnnCanonicalize");

      Op op = Downcast<Op>(call->op);

      if (fnoncomputational.get(op, false) && !fqnncanonicalize.count(op)) {

        return ExprMutator::VisitExpr_(call);

      }

      // If it is a primitive op call

      // then we must have a group assignment for it already.

      ICHECK(gmap_.count(call));

      if (call->op == stop_fusion_op) {

        return ExprMutator::VisitExpr(call->args[0]);

      }

      auto* ret_group = gmap_.at(call)->FindRoot();

      Array<Expr> new_args = GetNewArguments(call->args, ret_group);

      // 正常创建 Call 节点        

      auto new_call = Call(call->op, new_args, call->attrs, call->type_args, call->span);

      if (ret_group->root_ref == call) {  // 如果该节点是 group 的根节点

        // This is the root of the group

        // create the new call node.

        return MakeNewFunction(ret_group, call->checked_type(), new_call); // 将 Call 节点子图分支封装成 function

      } else {

        // This is an intermediate node of a fused function

        // simply return the new call.

        return std::move(new_call);

      }

    } else {

      return ExprMutator::VisitExpr_(call);

    }

  }