add piano graph executor

paddle/fluid/compiler/paddle2piano/CMakeLists.txt

@@ -5,5 +5,8 @@ cc_test(piano_compile_pass_test SRCS piano_compile_pass_tester.cc DEPS piano_com
 cc_library(piano_op_registry SRCS piano_op_registry.cc DEPS framework_proto op_registry note_proto piano_data_description)
 cc_test(piano_op_registry_test SRCS piano_op_registry_test.cc DEPS piano_op_registry operator op_registry)
 
-cc_library(piano_op_kernel_context SRCS piano_op_kernel_context.cc DEPS piano_op_registry proto_desc note_builder)
+cc_library(piano_op_kernel_context SRCS piano_op_kernel_context.cc DEPS piano_op_registry proto_desc piano_symbolization_builder)
 cc_test(piano_op_kernel_context_test SRCS piano_op_kernel_context_test.cc DEPS piano_op_kernel_context op_registry)
+
+cc_library(piano_graph_executor SRCS piano_graph_executor.cc DEPS piano_op_kernel_context piano_symbolization_meat_op)
+cc_test(piano_graph_executor_test SRCS piano_graph_executor_test.cc DEPS piano_graph_executor node)

paddle/fluid/compiler/paddle2piano/piano_graph_executor.cc

@@ -0,0 +1,151 @@
+/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+
+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 "paddle/fluid/compiler/paddle2piano/piano_graph_executor.h"
+
+#include <queue>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "paddle/fluid/compiler/paddle2piano/piano_op_kernel_context.h"
+#include "paddle/fluid/compiler/paddle2piano/vartype2notetype.h"
+#include "paddle/fluid/compiler/piano/symbolization/meta_op.h"
+#include "paddle/fluid/platform/enforce.h"
+
+namespace paddle {
+namespace piano {
+
+using framework::ir::Node;
+using GraphNodeVec = PianoGraphExecutor::GraphNodeVec;
+
+void CreateInputOperand(const GraphNodeVec& cluster_inputs, PianoScope* scope,
+                        symbolization::NoteBuilder* builder) {
+  for (int64_t id = 0; id < cluster_inputs.size(); ++id) {
+    auto* node = cluster_inputs.at(id);
+    PADDLE_ENFORCE_EQ(node->IsVar(), true,
+                      platform::errors::InvalidArgument(
+                          "Cluster Sub-Graph Input should be var"));
+
+    const auto& var_name = node->Name();
+
+    // create operand shape
+    const auto& var_shape = node->Var()->GetShape();
+    const auto& var_type = node->Var()->GetDataType();
+
+    // convert framework vartype to piano note type
+    note::ElementTypeProto element_type = VarType2NoteType(var_type);
+    Shape operand_shape(element_type, var_shape);
+
+    // create Operand
+    symbolization::Operand op =
+        symbolization::Parameter(builder, id, operand_shape, var_name);
+
+    // store into PianoScope
+    scope->SetOperand(var_name, op);
+  }
+}
+
+void TopologicSortGraph(const GraphNodeVec& cluster,
+                        GraphNodeVec* cluster_sorted) {
+  std::unordered_set<Node*> cluster_set(cluster.cbegin(), cluster.cend());
+
+  std::unordered_map<Node*, std::unordered_set<Node*>> in_ops;
+  std::unordered_map<Node*, std::unordered_set<Node*>> out_ops;
+  std::queue<Node*> topo_queue;
+
+  // ensure all op node in 'in_ops' and 'out_ops'
+  for (auto* n : cluster) {
+    PADDLE_ENFORCE_EQ(n->IsOp(), true,
+                      platform::errors::InvalidArgument(
+                          "Cluster Sub-Graph all should be op"));
+
+    in_ops.emplace(n, std::unordered_set<Node*>());
+    out_ops.emplace(n, std::unordered_set<Node*>());
+  }
+
+  // record all op's input op and output op
+  for (auto* n : cluster) {
+    // the op's input is var
+    for (auto* in_var : n->inputs) {
+      // the var's input is op
+      for (auto* in_op : in_var->inputs) {
+        if (cluster_set.find(in_op) != cluster_set.end()) {
+          in_ops.at(n).insert(in_op);
+          out_ops.at(in_op).insert(n);
+        }
+      }
+    }
+  }
+
+  // find topology entrance
+  for (auto* n : cluster) {
+    if (in_ops.at(n).empty()) {
+      topo_queue.push(n);
+    }
+  }
+
+  // topological sorting
+  while (!topo_queue.empty()) {
+    auto* cur_op = topo_queue.front();
+    topo_queue.pop();
+
+    cluster_sorted->emplace_back(cur_op);
+    for (auto* out : out_ops.at(cur_op)) {
+      // decrease output op's in-degree
+      in_ops.at(out).erase(cur_op);
+
+      // if empty, push into queue
+      if (in_ops.at(out).empty()) {
+        topo_queue.push(out);
+      }
+    }
+  }
+}
+
+void RunCompile(const GraphNodeVec& cluster, PianoScope* scope,
+                symbolization::NoteBuilder* builder) {
+  for (auto* n : cluster) {
+    const auto& op_name = n->Name();
+    const auto* op_desc = n->Op();
+
+    const auto& op_kernel_map = PianoOpRegistry::AllPianoOpKernels(op_name);
+    // TODO(jiangcheng05): how to distinguish library's kernel, like cudnn?
+    op_kernel_map.at("PLAIN")(PianoOpKernelContext(op_desc, scope, builder));
+  }
+}
+
+note::ModuleProto PianoGraphExecutor::operator()() {
+  // Step1: create unique NoteBuilder
+  std::string builder_name = "NoteBuilderOfGraph_";
+  builder_name.append(std::to_string(graph_id_));
+
+  symbolization::NoteBuilder builder(builder_name);
+
+  // Step2: create graph's input operand
+  PianoScope scope;
+  CreateInputOperand(cluster_inputs_, &scope, &builder);
+
+  // Step3: topo sort graph
+  GraphNodeVec cluster_sorted;
+  TopologicSortGraph(cluster_, &cluster_sorted);
+
+  // Step4: get PianoOpKernel and run compile
+  RunCompile(cluster_sorted, &scope, &builder);
+
+  // Step5: build and return module
+  return builder.Build();
+}
+
+}  // namespace piano
+}  // namespace paddle

paddle/fluid/compiler/paddle2piano/piano_graph_executor.h

@@ -0,0 +1,81 @@
+/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+
+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. */
+
+#pragma once
+
+#include <vector>
+
+#include "paddle/fluid/compiler/piano/note/note.pb.h"
+#include "paddle/fluid/framework/ir/node.h"
+
+namespace paddle {
+namespace piano {
+
+// An executor accept sub-graph which is generated by PianoCompilePass,
+// run each op's PianoOpKernel, finally return the graph's ModuleProto.
+//
+// Parameter:
+// 1. graph_id: the unique graph id, used for generating unique notebuilder name
+// 2. cluster: a vector which contains all graph op, non-topological-sorting.
+// 3. cluster_inputs: a vector which contains all graph's input var, the var's
+//                    input are outside op, the output are inside op
+// 4. cluster_outputs: a vector which contains all graph's output var, the var's
+//                     input are inside op, the output are outside op
+// 5. cluster_internals: a vector which contains all graph's internal var, the
+//                        var's input and output are inside op
+//
+// Example:
+//        -------------------------> op3 -> var4 ->
+//      /                            /
+// -> var1 -> op1 -> var2 -> op2 -> var3
+//
+// cluster: [op1, op2, op3]
+// cluster_inputs: [var1]
+// cluster_outputs: [var4]
+// cluster_internals: [var2, var3]
+//
+// Describe:
+// The executor consisted by the following step:
+// 1. create a NoteBuilder, it's name is unique for each graph
+// 2. create PianoScope, initially, scope only consist graph's input var and its
+// operand
+// 3. topological sorting graph
+// 4. create PianoOpKernelContext and run each op's PianoOpKernel
+// 5. run NoteBuilder's Build function to generate graph's ModuleProto
+class PianoGraphExecutor {
+ public:
+  using GraphNodeVec = std::vector<framework::ir::Node*>;
+
+  PianoGraphExecutor(int64_t graph_id, const GraphNodeVec& cluster,
+                     const GraphNodeVec& cluster_inputs,
+                     const GraphNodeVec& cluster_outputs,
+                     const GraphNodeVec& cluster_internals)
+      : graph_id_(graph_id),
+        cluster_(cluster),
+        cluster_inputs_(cluster_inputs),
+        cluster_outputs_(cluster_outputs),
+        cluster_internals_(cluster_internals) {}
+
+  note::ModuleProto operator()();
+
+ private:
+  int64_t graph_id_;
+  const GraphNodeVec& cluster_;
+  const GraphNodeVec& cluster_inputs_;
+  const GraphNodeVec& cluster_outputs_;
+  const GraphNodeVec& cluster_internals_;
+};
+
+}  // namespace piano
+}  // namespace paddle