Merge remote-tracking branch 'origin/develop' into to_tensor

Author: DongBaiYue

ci/check_approval.sh

@@ -309,6 +309,12 @@ if [ "${ALL_PADDLE_ENFORCE}" != "" ] && [ "${PR_ID}" != "" ]; then
  check_approval 1 luotao1 zhangbo9674 phlrain
 fi
 
+CHINESE_CHECK=$(git diff -U0 upstream/$BRANCH |grep "^+" |grep -P '[\p{Han}]')
+if [ "${CHINESE_CHECK}" != "" ] && [ "${PR_ID}" != "" ]; then
+echo_line="Not recommended to use Chinese. You must have one RD (tianshuo78520a or swgu98 or zhangbo9674 or risemeup1) approval."
+ check_approval 1 tianshuo78520a swgu98 zhangbo9674 risemeup1
+fi
+
 ALL_ADDED_LINES=$(git diff -U0 upstream/$BRANCH |grep "^+" || true)
 ALL_PADDLE_CHECK=$(echo $ALL_ADDED_LINES |grep -zoE "(PADDLE_ENFORCE[A-Z_]{0,9}|PADDLE_THROW)\(.[^,\);]*.[^;]*\);\s" || true)
 VALID_PADDLE_CHECK=$(echo "$ALL_PADDLE_CHECK" | grep -zoE '(PADDLE_ENFORCE[A-Z_]{0,9}|PADDLE_THROW)\(([^,;]+,)*[^";]*errors::.[^"]*".[^";]{20,}.[^;]*\);\s' || true)

cmake/cinn.cmake

@@ -26,12 +26,21 @@ else()
 endif()
 
 if(NOT DEFINED ENV{runtime_include_dir})
- message(
- STATUS
- "set runtime_include_dir: ${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/cuda")
- set(ENV{runtime_include_dir} "${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/cuda")
- add_definitions(
- -DRUNTIME_INCLUDE_DIR="${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/cuda")
+ if(WITH_GPU)
+ message(
+ STATUS
+ "set runtime_include_dir: ${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/cuda")
+ set(ENV{runtime_include_dir} "${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/cuda")
+ add_definitions(
+ -DRUNTIME_INCLUDE_DIR="${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/cuda")
+ elseif(WITH_ROCM)
+ message(
+ STATUS
+ "set runtime_include_dir: ${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/hip")
+ set(ENV{runtime_include_dir} "${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/hip")
+ add_definitions(
+ -DRUNTIME_INCLUDE_DIR="${CMAKE_SOURCE_DIR}/paddle/cinn/runtime/hip")
+ endif()
 endif()
 
 if(WITH_TESTING)
@@ -118,6 +127,10 @@ if(WITH_ROCM)
  add_definitions(-DCINN_WITH_HIP)
  endif()
  link_libraries(${ROCM_HIPRTC_LIB})
+
+ message(
+ STATUS "copy paddle/cinn/common/float16.h to $ENV{runtime_include_dir}")
+ file(COPY paddle/cinn/common/float16.h DESTINATION $ENV{runtime_include_dir})
 endif()
 
 set(cinnapi_src CACHE INTERNAL "" FORCE)

paddle/cinn/hlir/dialect/operator/transforms/pd_to_cinn_pass.cc

@@ -742,9 +742,7 @@ class SplitOpPattern : public pir::OpRewritePattern<paddle::dialect::SplitOp> {
  using pir::OpRewritePattern<paddle::dialect::SplitOp>::OpRewritePattern;
 
  bool Match(paddle::dialect::SplitOp op) const override {
- const bool is_denied = CompatibleInfo::IsDeniedForCinn(*op.operation());
-
- return !is_denied && PatternConstraint(op);
+ return PatternConstraint(op);
  }
 
  void Rewrite(paddle::dialect::SplitOp op,

paddle/cinn/runtime/cuda/cinn_cuda_runtime_source.cuh

@@ -338,7 +338,7 @@ extern "C" {
 
 __device__ inline int FN_INT32(pow)(int a, int b) {
  if (a == 0 && b < 0) {
- return -1;
+ return 0;
  }
  float res = pow(__int2float_rd(a), __int2float_rd(b));
  return __float2int_rn(res);
@@ -418,6 +418,9 @@ __device__ inline long long int FN_INT64(exp)(long long int a) {
 
 __device__ inline long long int FN_INT64(pow)(long long int a,
  long long int b) {
+ if (a == 0 && b < 0) {
+ return 0;
+ }
  double res = pow(__ll2double_rd(a), __ll2double_rd(b));
  return __double2ll_rn(res);
 }

paddle/fluid/framework/details/build_strategy.cc

@@ -321,7 +321,7 @@ ir::Graph *BuildStrategy::Apply(ir::Graph *graph,
  continue;
  }
  } else if (pass->Type() == "onednn_placement_pass") {
- pass->Set("mkldnn_enabled_op_types",
+ pass->Set("onednn_enabled_op_types",
  new std::unordered_set<std::string>(onednn_enabled_op_types_));
  }
  VLOG(1) << "Start Apply Pass " << pass->Type();

paddle/fluid/framework/ir/onednn/onednn_placement_pass.cc

@@ -64,7 +64,7 @@ inline bool FoundPhiOneDNNKernelWithCorrectDataType(
  return false;
 }
 
-bool MKLDNNPlacementPass::IsSupport(const Node* op) const {
+bool ONEDNNPlacementPass::IsSupport(const Node* op) const {
  if (FoundOneDNNKernelWithCorrectDataType(op) ||
  FoundPhiOneDNNKernelWithCorrectDataType(op)) {
  // For interpolate ops, there's a little difference between Paddle and
@@ -89,8 +89,8 @@ bool MKLDNNPlacementPass::IsSupport(const Node* op) const {
 
 } // namespace paddle::framework::ir
 
-REGISTER_PASS(onednn_placement_pass, paddle::framework::ir::MKLDNNPlacementPass)
- .RequirePassAttr("mkldnn_enabled_op_types");
+REGISTER_PASS(onednn_placement_pass, paddle::framework::ir::ONEDNNPlacementPass)
+ .RequirePassAttr("onednn_enabled_op_types");
 
 REGISTER_PASS_CAPABILITY(onednn_placement_pass)
  .AddCombination(

paddle/fluid/framework/ir/onednn/onednn_placement_pass.h

@@ -26,17 +26,17 @@ namespace ir {
 /*
  * Specifies which operators should use MKLDNN.
  */
-class MKLDNNPlacementPass : public PlacementPassBase {
+class ONEDNNPlacementPass : public PlacementPassBase {
  protected:
  bool IsSupport(const Node* op) const override;
 
  private:
- const std::string GetPlacementName() const override { return "MKLDNN"; }
+ const std::string GetPlacementName() const override { return "ONEDNN"; }
 
  const std::string GetAttrName() const override { return "use_mkldnn"; }
 
  const std::unordered_set<std::string> GetOpTypesList() const override {
- return Get<std::unordered_set<std::string>>("mkldnn_enabled_op_types");
+ return Get<std::unordered_set<std::string>>("onednn_enabled_op_types");
  }
 };
 

paddle/fluid/framework/ir/onednn/onednn_placement_pass_tester.cc

@@ -133,7 +133,7 @@ class PlacementPassTest {
 
  auto pass = PassRegistry::Instance().Get("onednn_placement_pass");
 
- pass->Set("mkldnn_enabled_op_types",
+ pass->Set("onednn_enabled_op_types",
  new std::unordered_set<std::string>(onednn_enabled_op_types));
 
  graph.reset(pass->Apply(graph.release()));
@@ -143,8 +143,10 @@ class PlacementPassTest {
  for (auto* node : graph->Nodes()) {
  if (node->IsOp()) {
  auto* op = node->Op();
- if (op->HasAttr("use_mkldnn") &&
- PADDLE_GET_CONST(bool, op->GetAttr("use_mkldnn"))) {
+ if ((op->HasAttr("use_mkldnn") &&
+ PADDLE_GET_CONST(bool, op->GetAttr("use_mkldnn"))) ||
+ (op->HasAttr("use_onednn") &&
+ PADDLE_GET_CONST(bool, op->GetAttr("use_onednn")))) {
  ++use_onednn_true_count;
  }
  }
@@ -156,27 +158,27 @@ class PlacementPassTest {
  void PlacementNameTest() {
  auto pass = PassRegistry::Instance().Get("onednn_placement_pass");
  EXPECT_EQ(static_cast<PlacementPassBase*>(pass.get())->GetPlacementName(),
- "MKLDNN");
+ "ONEDNN");
  }
 };
 
-TEST(MKLDNNPlacementPass, enable_conv_relu) {
+TEST(ONEDNNPlacementPass, enable_conv_relu) {
  // 2 conv (1 conv is always true) + 2 relu (1 relu is always true) + 0 pool
  PlacementPassTest().MainTest({"conv2d", "relu"}, 4);
 }
 
-TEST(MKLDNNPlacementPass, enable_relu_pool) {
+TEST(ONEDNNPlacementPass, enable_relu_pool) {
  // 1 conv (1 conv is always true) + 2 relu (1 relu is always true) + 1 pool
  PlacementPassTest().MainTest({"relu", "pool2d"}, 4);
 }
 
-TEST(MKLDNNPlacementPass, enable_all) {
+TEST(ONEDNNPlacementPass, enable_all) {
  // 2 conv (1 conv is always true) + 2 relu (1 relu is always true) + 1 pool +
  // 1 concat
  PlacementPassTest().MainTest({}, 6);
 }
 
-TEST(MKLDNNPlacementPass, placement_name) {
+TEST(ONEDNNPlacementPass, placement_name) {
  PlacementPassTest().PlacementNameTest();
 }
 

paddle/fluid/inference/analysis/argument.h

@@ -193,12 +193,12 @@ struct Argument {
  // whether to mute all logs in inference.
  DECL_ARGUMENT_FIELD(disable_logs, DisableLogs, bool);
 
- // Pass a set of op types to enable its mkldnn kernel
- DECL_ARGUMENT_FIELD(mkldnn_enabled_op_types,
- MKLDNNEnabledOpTypes,
+ // Pass a set of op types to enable its onednn kernel
+ DECL_ARGUMENT_FIELD(onednn_enabled_op_types,
+ ONEDNNEnabledOpTypes,
  std::unordered_set<std::string>);
- // The cache capacity of different input shapes for mkldnn.
- DECL_ARGUMENT_FIELD(mkldnn_cache_capacity, MkldnnCacheCapacity, int);
+ // The cache capacity of different input shapes for onednn.
+ DECL_ARGUMENT_FIELD(mkldnn_cache_capacity, OnednnCacheCapacity, int);
 
 #ifdef PADDLE_WITH_DNNL
  // A set of op types to enable their quantized kernels
@@ -219,7 +219,7 @@ struct Argument {
  Bfloat16EnabledOpTypes,
  std::unordered_set<std::string>);
 
- DECL_ARGUMENT_FIELD(use_onednn_int8, UseMkldnnInt8, bool);
+ DECL_ARGUMENT_FIELD(use_onednn_int8, UseOnednnInt8, bool);
 #endif
 
  // Passed from config.

paddle/fluid/inference/analysis/ir_pass_manager.cc

@@ -131,9 +131,9 @@ void IRPassManager::CreatePasses(Argument *argument,
  pass->Set("optim_cache_dir", new std::string(std::move(optim_cache_dir)));
  pass_num++;
  } else if (pass_name == "onednn_placement_pass") {
- pass->Set("mkldnn_enabled_op_types",
+ pass->Set("onednn_enabled_op_types",
  new std::unordered_set<std::string>(
- argument->mkldnn_enabled_op_types()));
+ argument->onednn_enabled_op_types()));
  } else if (pass_name == "cudnn_placement_pass") {
  pass->Set("cudnn_enabled_op_types",
  new std::unordered_set<std::string>());