Add ir execution (#54259)

* refine code

* refine code

* add interface

* add ir exe test

* add ir exe

* split phi kernel adaptor to single file

* remov useless code

* fix bug

* not user impl

* add res log for windows debug

* add log for window

* remove op_gen change

* remove op gen

* add op gen

* fix bug

* revert opgen value file

* fix bug

---------
Co-authored-by: Nzhangbo9674 <zhangbo54@baidu.com>

test/cpp/ir/core/CMakeLists.txt

@@ -22,6 +22,16 @@ cc_test_old(
   phi
   gtest)
 
+cc_test_old(
+  ir_exe_test
+  SRCS
+  ir_exe_test.cc
+  DEPS
+  new_ir
+  pd_dialect
+  phi
+  gtest)
+
 file(
   DOWNLOAD
   https://paddle-ci.gz.bcebos.com/ir_translator_test/restnet50_main.prog

test/cpp/ir/core/ir_exe_test.cc

+// Copyright (c) 2023 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 <gtest/gtest.h>
+
+#include "paddle/fluid/ir/dialect/pd_dialect.h"
+#include "paddle/fluid/ir/dialect/pd_interface.h"
+#include "paddle/fluid/ir/dialect/pd_type.h"
+#include "paddle/fluid/ir/dialect/utils.h"
+#include "paddle/ir/core/builtin_attribute.h"
+#include "paddle/ir/core/builtin_dialect.h"
+#include "paddle/ir/core/builtin_op.h"
+#include "paddle/ir/core/ir_context.h"
+#include "paddle/ir/core/program.h"
+#include "paddle/ir/core/utils.h"
+#include "paddle/phi/core/meta_tensor.h"
+#include "paddle/phi/infermeta/binary.h"
+#include "paddle/phi/kernels/elementwise_add_kernel.h"
+
+#include "paddle/fluid/framework/scope.h"
+#include "paddle/fluid/framework/tensor.h"
+#include "paddle/fluid/framework/variable.h"
+#include "paddle/fluid/framework/variable_helper.h"
+
+#include "paddle/phi/common/place.h"
+#include "paddle/phi/core/kernel_context.h"
+#include "paddle/phi/core/kernel_factory.h"
+
+#include "paddle/fluid/platform/init.h"
+
+#include "paddle/fluid/ir/dialect/pd_attribute.h"
+
+#include "paddle/phi/core/kernel_registry.h"
+#include "test/cpp/ir/core/phi_kernel_adaptor.h"
+
+PD_DECLARE_KERNEL(uniform, CPU, ALL_LAYOUT);
+PD_DECLARE_KERNEL(add, CPU, ALL_LAYOUT);
+
+bool simple_cmp(float a, float b) { return std::abs((a - b) / a) < 1e-5; }
+
+TEST(program_test, program) {
+  ir::IrContext* ctx = ir::IrContext::Instance();
+  ctx->GetOrRegisterDialect<paddle::dialect::PaddleDialect>();
+
+  ir::Program program(ctx);
+  ir::Block* block = program.block();
+  ir::Type fp32_dtype = ir::Float32Type::get(ctx);
+
+  paddle::dialect::DenseTensorTypeStorage::Dim dims = {2, 2};
+  paddle::dialect::DenseTensorTypeStorage::DataLayout data_layout =
+      paddle::dialect::DenseTensorTypeStorage::DataLayout::NCHW;
+  paddle::dialect::DenseTensorTypeStorage::LoD lod = {};
+  size_t offset = 0;
+  ir::Type dense_tensor_dtype = paddle::dialect::DenseTensorType::get(
+      ctx, fp32_dtype, dims, data_layout, lod, offset);
+
+  // (1) Def a = GetParameterOp("a")
+  std::string op1_name = std::string(paddle::dialect::UniformOp::name());
+  ir::OpInfo op1_info = ctx->GetRegisteredOpInfo(op1_name);
+
+  // ir::Attribute shape_1 = ir::ArrayAttribute::get(ctx, {ten} );
+  ir::Attribute shape_1 = paddle::dialect::IntArrayAttribute::get(
+      ctx, std::vector<int64_t>({2, 2}));
+  ir::Attribute data_type =
+      paddle::dialect::DataTypeAttribute::get(ctx, phi::DataType::FLOAT32);
+  ir::Attribute min =
+      paddle::dialect::ScalarAttribute::get(ctx, phi::Scalar(0.0));
+  ir::Attribute max =
+      paddle::dialect::ScalarAttribute::get(ctx, phi::Scalar(1.0));
+  ir::Attribute seed = ir::Int32_tAttribute::get(ctx, 2);
+  ir::Attribute uni_place = paddle::dialect::PlaceAttribute::get(
+      ctx, phi::Place(phi::AllocationType::CPU));
+  std::unordered_map<std::string, ir::Attribute> op1_attribute{
+      {"shape", shape_1},
+      {"dtype", data_type},
+      {"min", min},
+      {"max", max},
+      {"seed", seed},
+      {"place", uni_place}};
+  ir::Operation* op1 =
+      ir::Operation::create({}, op1_attribute, {dense_tensor_dtype}, op1_info);
+
+  block->push_back(op1);
+
+  // (2) Def b = GetParameterOp("b")
+  std::string op2_name = std::string(paddle::dialect::UniformOp::name());
+  ir::OpInfo op2_info = ctx->GetRegisteredOpInfo(op2_name);
+  ir::Attribute ten2 = ir::Int32_tAttribute::get(ctx, 3);
+  std::unordered_map<std::string, ir::Attribute> op2_attribute{{"shape", ten2}};
+  ir::Operation* op2 =
+      ir::Operation::create({}, op1_attribute, {dense_tensor_dtype}, op2_info);
+  block->push_back(op2);
+
+  // (3) Def out = AddOp(a, b)
+  std::string add_op_name = std::string(paddle::dialect::AddOp::name());
+  ir::OpInfo add_op_info = ctx->GetRegisteredOpInfo(add_op_name);
+  ir::Operation* add_op = ir::Operation::create(
+      {op1->GetResultByIndex(0), op2->GetResultByIndex(0)},
+      {},
+      {dense_tensor_dtype},
+      add_op_info);
+  block->push_back(add_op);
+
+  paddle::framework::Scope scope;
+
+  PhiKernelAdaptor phi_kernel_adaptor(&scope);
+
+  phi_kernel_adaptor.run(&program);
+
+  auto out_tensor =
+      scope.Var(phi_kernel_adaptor.out_name)->Get<phi::DenseTensor>();
+
+  bool res0 = simple_cmp(out_tensor.data<float>()[0], 1.80721);
+  bool res1 = simple_cmp(out_tensor.data<float>()[1], 1.70047);
+  bool res2 = simple_cmp(out_tensor.data<float>()[2], 1.56764);
+  bool res3 = simple_cmp(out_tensor.data<float>()[3], 1.85063);
+  std::cerr << out_tensor.data<float>()[0] << "\t"
+            << out_tensor.data<float>()[1] << "\t"
+            << out_tensor.data<float>()[2] << "\t"
+            << out_tensor.data<float>()[3] << std::endl;
+  EXPECT_EQ(res0, true);
+  EXPECT_EQ(res1, true);
+  EXPECT_EQ(res2, true);
+  EXPECT_EQ(res3, true);
+}

test/cpp/ir/core/phi_kernel_adaptor.h

+// Copyright (c) 2023 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 "paddle/fluid/ir/dialect/pd_dialect.h"
+#include "paddle/fluid/ir/dialect/pd_interface.h"
+#include "paddle/fluid/ir/dialect/pd_op.h"
+#include "paddle/fluid/ir/dialect/pd_type.h"
+#include "paddle/fluid/ir/dialect/utils.h"
+#include "paddle/ir/core/builtin_attribute.h"
+#include "paddle/ir/core/builtin_dialect.h"
+#include "paddle/ir/core/builtin_op.h"
+#include "paddle/ir/core/ir_context.h"
+#include "paddle/ir/core/program.h"
+#include "paddle/ir/core/utils.h"
+#include "paddle/phi/core/meta_tensor.h"
+#include "paddle/phi/infermeta/binary.h"
+#include "paddle/phi/kernels/elementwise_add_kernel.h"
+
+#include "paddle/fluid/framework/scope.h"
+#include "paddle/fluid/framework/tensor.h"
+#include "paddle/fluid/framework/variable.h"
+#include "paddle/fluid/framework/variable_helper.h"
+
+#include "paddle/phi/common/place.h"
+#include "paddle/phi/core/kernel_context.h"
+#include "paddle/phi/core/kernel_factory.h"
+
+#include "paddle/fluid/platform/init.h"
+
+#include "paddle/fluid/ir/dialect/pd_attribute.h"
+
+#include "glog/logging.h"
+
+void build_scope(ir::Block* block,
+                 paddle::framework::Scope* scope,
+                 std::unordered_map<ir::Value, std::string>* name_map) {
+  std::unordered_map<ir::Value, int> map_test;
+
+  int count = 0;
+  for (auto it = block->begin(); it != block->end(); ++it) {
+    int input = (*it)->num_operands();
+    if (input > 0) {
+      for (int i = 0; i < input; ++i) {
+        auto ptr = (*it)->GetOperandByIndex(i).source();
+        std::string name;
+        if (name_map->find(ptr) != name_map->end()) {
+          name = name_map->at(ptr);
+        } else {
+          name = "var_" + std::to_string(count++);
+          name_map->emplace(ptr, name);
+        }
+        auto var = scope->Var(name);
+        // need to update here, only support DenseTensor
+        var->GetMutable<phi::DenseTensor>();
+      }
+    }
+
+    int out_num = (*it)->num_results();
+
+    if (out_num > 0) {
+      for (int i = 0; i < out_num; ++i) {
+        ir::Value ptr = (*it)->GetResultByIndex(i);
+        std::string name;
+        if (name_map->find(ptr) != name_map->end()) {
+          name = name_map->at(ptr);
+        } else {
+          name = "var_" + std::to_string(count++);
+          name_map->emplace(ptr, name);
+        }
+        auto var = scope->Var(name);
+
+        var->GetMutable<phi::DenseTensor>();
+      }
+    }
+  }
+}
+
+template <typename T>
+void build_context(ir::Operation* op,
+                   const std::unordered_map<ir::Value, std::string>& name_map,
+                   paddle::framework::Scope* scope,
+                   T* ctx,
+                   bool is_infer_meta = true) {
+  paddle::dialect::GetOpInfoInterface op_info_interface =
+      op->dyn_cast<paddle::dialect::GetOpInfoInterface>();
+  auto op_info_res = op_info_interface.GetOpInfo();
+
+  auto input_info = std::get<0>(op_info_res);
+
+  std::set<std::string> input_set;
+  for (auto& t : input_info) {
+    VLOG(6) << t.name << "\t" << t.type_name;
+
+    input_set.insert(t.name);
+  }
+
+  auto attr_map = op->attributes();
+
+  std::map<std::string, std::string> attr_type_map;
+  auto attr_info = std::get<1>(op_info_res);
+  for (auto& t : attr_info) {
+    VLOG(6) << t.name << "\t" << t.type_name;
+    attr_type_map[t.name] = t.type_name;
+  }
+
+  auto runtime_info = std::get<3>(op_info_res);
+
+  int input_index = 0;
+  std::vector<std::string> vec_param_list;
+  if (is_infer_meta) {
+    vec_param_list = runtime_info.infer_meta_param;
+  } else {
+    vec_param_list = runtime_info.kernel_param;
+  }
+  for (auto& t : vec_param_list) {
+    if (input_set.count(t)) {
+      // get information from input
+      ir::Value ptr = op->GetOperandByIndex(input_index++).source();
+      auto in_var_name = name_map.at(ptr);
+
+      ctx->EmplaceBackInput(
+          scope->Var(in_var_name)->GetMutable<phi::DenseTensor>());
+    }
+
+    if (attr_type_map.count(t)) {
+      auto type_name = attr_type_map[t];
+      if (type_name == "paddle::dialect::IntArrayAttribute") {
+        ctx->EmplaceBackAttr(
+            attr_map[t].dyn_cast<paddle::dialect::IntArrayAttribute>().data());
+      } else if (type_name == "paddle::dialect::DataTypeAttribute") {
+        ctx->EmplaceBackAttr(
+            attr_map[t].dyn_cast<paddle::dialect::DataTypeAttribute>().data());
+      } else if (type_name == "paddle::dialect::ScalarAttribute") {
+        ctx->EmplaceBackAttr(
+            attr_map[t].dyn_cast<paddle::dialect::ScalarAttribute>().data());
+      } else if (type_name == "ir::Int32_tAttribute") {
+        ctx->EmplaceBackAttr(
+            attr_map[t].dyn_cast<ir::Int32_tAttribute>().data());
+      } else if (type_name == "paddle::dialect::PlaceAttribute") {
+        ctx->EmplaceBackAttr(
+            attr_map[t].dyn_cast<paddle::dialect::PlaceAttribute>().data());
+      } else {
+        PADDLE_THROW(phi::errors::Unimplemented("attr type not support [%s] ",
+                                                type_name));
+      }
+    }
+  }
+
+  ir::Value out_ptr = op->GetResultByIndex(0);
+  auto name = name_map.at(out_ptr);
+
+  ctx->EmplaceBackOutput(scope->Var(name)->GetMutable<phi::DenseTensor>());
+}
+
+class PhiKernelAdaptor {
+ public:
+  explicit PhiKernelAdaptor(paddle::framework::Scope* scope) : scope_(scope) {}
+
+  void run(ir::Program* program) {
+    auto block = program->block();
+    std::unordered_map<ir::Value, std::string> name_map;
+    build_scope(block, scope_, &name_map);
+
+    auto* dev_ctx = phi::DeviceContextPool::Instance().Get(phi::CPUPlace());
+    phi::Place cpu_place(phi::AllocationType::CPU);
+    for (auto it = block->begin(); it != block->end(); ++it) {
+      VLOG(6) << "begin to run op " << (*it)->name();
+
+      auto attr_map = (*it)->attributes();
+
+      InferShapeInterface interface = (*it)->dyn_cast<InferShapeInterface>();
+      phi::InferMetaContext ctx;
+
+      build_context<phi::InferMetaContext>((*it), name_map, scope_, &ctx);
+
+      interface.InferShape(&ctx);
+
+      paddle::dialect::GetOpInfoInterface op_info_interface =
+          (*it)->dyn_cast<paddle::dialect::GetOpInfoInterface>();
+      auto op_info_res = op_info_interface.GetOpInfo();
+
+      auto runtime_info = std::get<3>(op_info_res);
+
+      auto phi_kernels = phi::KernelFactory::Instance().SelectKernelMap(
+          runtime_info.kernel_func[0]);
+
+      phi::KernelKey kernel_key(phi::TransToPhiBackend(cpu_place),
+                                phi::DataLayout::ANY,
+                                phi::DataType::FLOAT32);
+      auto found_it = phi_kernels.find(kernel_key);
+      if (found_it == phi_kernels.end()) {
+        std::cerr << "kernel name " << runtime_info.kernel_func[0] << std::endl;
+        std::cerr << "kernel key " << kernel_key.backend() << "\t"
+                  << kernel_key.dtype() << "\t" << kernel_key.layout()
+                  << std::endl;
+        PADDLE_THROW(paddle::platform::errors::NotFound(
+            "can not found kerenl for [%s]", (*it)->name()));
+      } else {
+        phi::KernelContext kernel_ctx(dev_ctx);
+
+        build_context<phi::KernelContext>(
+            (*it), name_map, scope_, &kernel_ctx, false);
+        found_it->second(&kernel_ctx);
+
+        auto out_value = (*it)->GetResultByIndex(0);
+        out_name = name_map[out_value];
+      }
+    }
+  }
+
+  std::string out_name;
+
+ private:
+  paddle::framework::Scope* scope_;
+};