PaddlePaddle · Enigmatisms · Aug 5, 2025 · Aug 6, 2025 · Aug 6, 2025 · Aug 6, 2025
diff --git a/.github/workflows/Slice-baseline.yml b/.github/workflows/Slice-baseline.yml
@@ -2,6 +2,13 @@ name: Slice-baseline-paddle
 
 on:
   workflow_dispatch:
+    inputs:
+      PR_ID:
+        required: false
+        type: string
+      COMMIT_ID:
+        required: false
+        type: string
   schedule:
     - cron: '0 20 * * 0'
 
@@ -43,3 +50,5 @@ jobs:
       docker_build_image: ${{ needs.build-docker.outputs.docker_build_image }}
       slice-check: 'true'
       SLICE_TEST_MODE: insert_baseline
+      MANUALLY_PR_ID: ${{ inputs.PR_ID }}
+      MANUALLY_COMMIT_ID: ${{ inputs.COMMIT_ID }}
diff --git a/.github/workflows/_Linux-XPU.yml b/.github/workflows/_Linux-XPU.yml
@@ -206,7 +206,7 @@ jobs:
           CCACHE_DIR: /root/.ccache
           CCACHE_MAXSIZE: 150G
           CCACHE_LIMIT_MULTIPLE: 0.8
-          IF_KUNLUN3: "OFF"
+          IF_KUNLUN3: "ON"
           GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           home_dir: ${{ github.workspace }}/../../../..
           FLAGS_use_stride_kernel: "0"

diff --git a/.github/workflows/_Slice.yml b/.github/workflows/_Slice.yml
@@ -20,6 +20,12 @@ on:
         type: string
         required: false
         default: 'paddle'
+      MANUALLY_PR_ID:
+        type: string
+        required: false
+      MANUALLY_COMMIT_ID:
+        type: string
+        required: false
 
 env:
   PR_ID: ${{ github.event.pull_request.number || '0' }}
@@ -47,6 +53,7 @@ jobs:
 
   slice:
     name: Slice test
+    needs: check-bypass
     if: ${{ inputs.can-skip != 'true' && needs.check-bypass.outputs.can-skip != 'true' }}
     runs-on:
       group: slice
@@ -105,7 +112,11 @@ jobs:
           if [[ "${{ inputs.SLICE_BENCHMARK_FRAMEWORKS }}" == "torch" ]];then
             python3.10 -m pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu118
           else
-            python3.10 -m pip install $wheel_link
+            if [[ "${{ inputs.MANUALLY_PR_ID }}" == "" ]]; then
+              python3.10 -m pip install $wheel_link
+            else
+              python3.10 -m pip install https://paddle-github-action.bj.bcebos.com/PR/build/${{ inputs.MANUALLY_PR_ID }}/${{ inputs.MANUALLY_COMMIT_ID }}/paddlepaddle_gpu-0.0.0-cp310-cp310-linux_x86_64.whl
+            fi
           fi
           python3.10 -m pip install -r PaddleTest/framework/e2e/api_benchmark/requirement.txt
           cd PaddleTest/framework/slice_benchmark

diff --git a/ci/check_approval.sh b/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)

diff --git a/ci/kunlun_test.sh b/ci/kunlun_test.sh
@@ -159,9 +159,10 @@ set +x
             git clone --depth 1000 https://gitee.com/paddlepaddle/PaddleX.git
             cd PaddleX
             pip install -e .
+            pip install numpy==1.24.4 pypdfium2
 
             #install paddle x dependency
-            paddlex --install PaddleClas
+            paddlex --install PaddleClas -y
 
             #download paddle dataset
             wget -q https://paddle-model-ecology.bj.bcebos.com/paddlex/data/cls_flowers_examples.tar -P ./dataset

diff --git a/cmake/cinn.cmake b/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)

diff --git a/doc/README_cn.md b/doc/README_cn.md
@@ -0,0 +1,6 @@
+# 致读者和开发者
+感谢您阅读 PaddlePaddle 文档。
+
+自 **2018年9月17日** 起，**0.15.0 及 develop** 分支的文档源码已迁移至 [FluidDoc Repo](https://github.com/PaddlePaddle/FluidDoc) 仓库 ，并将在该仓库中持续更新。
+
+请前往 FluidDoc 仓库获取最新文档。
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/pd_to_cinn_pass.cc b/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,

diff --git a/paddle/cinn/runtime/cuda/cinn_cuda_runtime_source.cuh b/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);
 }

diff --git a/paddle/common/layout.h b/paddle/common/layout.h
@@ -85,6 +85,8 @@ inline DataLayout StringToDataLayout(const std::string& str) {
     return DataLayout::kAnyLayout;
   } else if (s == "MKLDNNLAYOUT") {
     return DataLayout::kMKLDNN;
+  } else if (s == "ONEDNNLAYOUT") {
+    return DataLayout::ONEDNN;
   } else if (s == "SPARSE_COO") {
     return DataLayout::SPARSE_COO;
   } else if (s == "SPARSE_CSR") {

diff --git a/paddle/fluid/framework/details/build_strategy.cc b/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();

diff --git a/paddle/fluid/framework/ir/onednn/onednn_placement_pass.cc b/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(

diff --git a/paddle/fluid/framework/ir/onednn/onednn_placement_pass.h b/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");
   }
 };
 

diff --git a/paddle/fluid/framework/ir/onednn/onednn_placement_pass_tester.cc b/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();
 }
 

diff --git a/paddle/fluid/framework/new_executor/instruction/control_flow/if_instruction.cc b/paddle/fluid/framework/new_executor/instruction/control_flow/if_instruction.cc
@@ -119,7 +119,7 @@ IfInstruction::IfInstruction(size_t id,
       outputs.emplace(value, GetValueIds(value, *value_exec_info));
     }
     if (value.use_count() > 0) {
-      VLOG(6) << "value " << i << " use conutn != 0";
+      VLOG(6) << "value " << i << " use count != 0";
       is_last_op = false;
     }
   }

diff --git a/paddle/fluid/framework/new_executor/instruction/cuda_graph_instruction.cc b/paddle/fluid/framework/new_executor/instruction/cuda_graph_instruction.cc
@@ -109,7 +109,7 @@ CudaGraphInstruction::CudaGraphInstruction(
       outputs.emplace(value, GetValueIds(value, *value_exec_info));
     }
     if (value.use_count() > 0) {
-      VLOG(6) << "value " << i << " use conutn != 0";
+      VLOG(6) << "value " << i << " use count != 0";
       is_last_op = false;
     }
   }

diff --git a/paddle/fluid/framework/op_registry.h b/paddle/fluid/framework/op_registry.h
@@ -170,7 +170,7 @@ inline void RegisterKernelClass(const char* op_type,
   std::string library(library_type);
   std::string data_layout = "ANYLAYOUT";
   if (library == "MKLDNN") {
-    data_layout = "MKLDNNLAYOUT";
+    data_layout = "ONEDNNLAYOUT";
   }
 #ifdef PADDLE_WITH_CUSTOM_DEVICE
   if (std::is_same<PlaceType, phi::CustomPlace>::value) {

diff --git a/paddle/fluid/inference/analysis/argument.h b/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.

diff --git a/paddle/fluid/inference/analysis/ir_pass_manager.cc b/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>());

diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -1031,8 +1031,8 @@ void AnalysisPredictor::OptimizeInferencePirProgram() {
       }
 #endif
 #ifdef PADDLE_WITH_DNNL
-    } else if (config_.mkldnn_enabled()) {
-      // mkldnn
+    } else if (config_.onednn_enabled()) {
+      // onednn
       pir::IrContext *ctx = pir::IrContext::Instance();
       ctx->GetOrRegisterDialect<paddle::dialect::OneDNNOperatorDialect>();
       if (!config_.custom_pass_only_) {
@@ -2100,9 +2100,9 @@ void AnalysisPredictor::PrepareArgument() {
   argument_->SetIpuCustomPatterns(config_.ipu_custom_patterns_);
 #endif
 
-  if (config_.mkldnn_enabled() && !config_.use_gpu()) {
-    LOG(INFO) << "MKLDNN is enabled";
-    argument_->SetMKLDNNEnabledOpTypes(config_.onednn_enabled_op_types_);
+  if (config_.onednn_enabled() && !config_.use_gpu()) {
+    LOG(INFO) << "ONEDNN is enabled";
+    argument_->SetONEDNNEnabledOpTypes(config_.onednn_enabled_op_types_);
   }
 
   if (config_.cinn_enabled()) {
@@ -2115,7 +2115,7 @@ void AnalysisPredictor::PrepareArgument() {
     argument_->SetBfloat16EnabledOpTypes(config_.bfloat16_enabled_op_types_);
   }
 
-  if (config_.mkldnn_int8_enabled()) {
+  if (config_.onednn_int8_enabled()) {
     LOG(INFO) << "Int8 is enabled";
     argument_->SetQuantizeEnabledOpTypes(config_.quantize_enabled_op_types_);
     argument_->SetQuantizeExcludedOpIds(config_.quantize_excluded_op_ids_);
@@ -2296,7 +2296,7 @@ void AnalysisPredictor::OptimizeInferenceProgram() {
 #if defined(_WIN32)
   argument_->PartiallyRelease();
 #else
-  if (config_.mkldnn_enabled() ||
+  if (config_.onednn_enabled() ||
       (config_.tensorrt_engine_enabled() &&
        config_.tensorrt_precision_mode_ ==
            AnalysisConfig::Precision::kInt8)) {  // NOLINT

diff --git a/paddle/fluid/inference/capi/pd_config.cc b/paddle/fluid/inference/capi/pd_config.cc
@@ -311,7 +311,7 @@ bool PD_OnednnEnabled(const PD_AnalysisConfig* config) {
       config,
       common::errors::InvalidArgument(
           "The pointer of analysis configuration shouldn't be nullptr"));
-  return config->config.mkldnn_enabled();
+  return config->config.onednn_enabled();
 }
 
 void PD_SetCpuMathLibraryNumThreads(PD_AnalysisConfig* config,