Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle into fix_log2

Author: Joejiong

cmake/cblas.cmake

@@ -102,7 +102,7 @@ if(NOT DEFINED CBLAS_PROVIDER AND WITH_SYSTEM_BLAS)
   find_library(REFERENCE_CBLAS_LIBRARY NAMES cblas PATHS
         ${REFERENCE_CBLAS_LIB_SEARCH_PATHS})
   find_library(REFERENCE_BLAS_LIBRARY NAMES blas PATHS
-        ${REFERENCE_BLAS_LIB_SEARCH_PATHS})
+        ${REFERENCE_CBLAS_LIB_SEARCH_PATHS})
 
   if(REFERENCE_CBLAS_INCLUDE_DIR AND REFERENCE_CBLAS_LIBRARY)
     set(CBLAS_PROVIDER REFERENCE_CBLAS)
@@ -127,9 +127,9 @@ endif()
 # linear algebra libraries for cc_library(xxx SRCS xxx.c DEPS cblas)
 
 include_directories(${CBLAS_INC_DIR})
-if(NOT ${CBLAS_PROVIDER} STREQUAL MKLML)
-  target_link_libraries(cblas ${CBLAS_LIBRARIES})
-elseif(${CBLAS_PROVIDER} STREQUAL REFERENCE_CBLAS)
+if(${CBLAS_PROVIDER} STREQUAL REFERENCE_CBLAS)
   target_link_libraries(cblas gfortran ${CBLAS_LIBRARIES} ${REFERENCE_BLAS_LIBRARY})
+elseif(NOT ${CBLAS_PROVIDER} STREQUAL MKLML)
+  target_link_libraries(cblas ${CBLAS_LIBRARIES})
 endif()
 

cmake/cupti.cmake

@@ -8,6 +8,7 @@ find_path(CUPTI_INCLUDE_DIR cupti.h
         PATHS ${CUPTI_ROOT} ${CUPTI_ROOT}/include
         $ENV{CUPTI_ROOT} $ENV{CUPTI_ROOT}/include
         ${CUDA_TOOLKIT_ROOT_DIR}/extras/CUPTI/include
+        ${CUDA_TOOLKIT_ROOT_DIR}/targets/x86_64-linux/include
         NO_DEFAULT_PATH
         )
 
@@ -27,6 +28,7 @@ list(APPEND CUPTI_CHECK_LIBRARY_DIRS
         $ENV{CUPTI_ROOT}/lib64
         $ENV{CUPTI_ROOT}/lib
         /usr/lib
+        ${CUDA_TOOLKIT_ROOT_DIR}/targets/x86_64-linux/lib64
         ${CUDA_TOOLKIT_ROOT_DIR}/extras/CUPTI/lib64)
 find_library(CUPTI_LIBRARY NAMES libcupti.so libcupti.dylib # libcupti_static.a
        PATHS ${CUPTI_CHECK_LIBRARY_DIRS} ${CUPTI_INCLUDE_DIR} ${__libpath_hist}

cmake/external/pybind11.cmake

@@ -34,6 +34,11 @@ ExternalProject_Add(
         "${PYBIND_DOWNLOAD_CMD}"
         PREFIX            ${PYBIND_PREFIX_DIR}
         SOURCE_DIR        ${PYBIND_SOURCE_DIR}
+        # If we explicitly leave the `UPDATE_COMMAND` of the ExternalProject_Add
+        # function in CMakeLists blank, it will cause another parameter GIT_TAG
+        # to be modified without triggering incremental compilation, and the
+        # third-party library version changes cannot be incorporated.
+        # reference: https://cmake.org/cmake/help/latest/module/ExternalProject.html
         UPDATE_COMMAND    ""
         CONFIGURE_COMMAND ""
         BUILD_COMMAND     ""

paddle/fluid/framework/ir/CMakeLists.txt

@@ -23,9 +23,9 @@ function(pass_library TARGET DEST)
 
     cmake_parse_arguments(pass_library "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
     if(pass_library_DIR)
-        cc_library(${TARGET} SRCS ${pass_library_DIR}/${TARGET}.cc DEPS graph_pattern_detector pass fuse_pass_base ${pass_library_DEPS})
+        cc_library(${TARGET} SRCS ${pass_library_DIR}/${TARGET}.cc DEPS graph_pattern_detector pass fuse_pass_base op_version_registry ${pass_library_DEPS})
     else()
-        cc_library(${TARGET} SRCS ${TARGET}.cc DEPS graph_pattern_detector pass fuse_pass_base ${pass_library_DEPS})
+        cc_library(${TARGET} SRCS ${TARGET}.cc DEPS graph_pattern_detector pass fuse_pass_base op_version_registry ${pass_library_DEPS})
     endif()
 
     # add more DEST here, such as train, dist and collect USE_PASS into a file automatically.

paddle/fluid/framework/ir/graph_pattern_detector.cc

@@ -2102,7 +2102,7 @@ PDNode *patterns::Bfloat16Placement::operator()(
     const std::unordered_set<std::string> &bfloat16_enabled_op_types) {
   std::unordered_set<std::string> supported_op_types =
       std::unordered_set<std::string>(
-          {"concat", "conv2d", "fusion_gru", "reshape2", "transpose2"});
+          {"concat", "conv2d", "fusion_gru", "reshape2", "transpose2", "sum"});
   if (!bfloat16_enabled_op_types.empty()) {
     supported_op_types = bfloat16_enabled_op_types;
   }

paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass.cc

@@ -147,12 +147,19 @@ void ConvBiasFusePass::ApplyImpl(ir::Graph* graph) const {
 }  // namespace paddle
 REGISTER_PASS(conv_bias_mkldnn_fuse_pass,
               paddle::framework::ir::ConvBiasFusePass);
-REGISTER_PASS(conv_transpose_bias_mkldnn_fuse_pass,
-              paddle::framework::ir::Conv2DTransposeBiasFusePass);
-REGISTER_PASS(conv3d_bias_mkldnn_fuse_pass,
-              paddle::framework::ir::Conv3DBiasFusePass);
 REGISTER_PASS_CAPABILITY(conv_bias_mkldnn_fuse_pass)
     .AddCombination(
         paddle::framework::compatible::OpVersionComparatorCombination()
             .EQ("conv2d", 0)
             .EQ("elementwise_add", 0));
+
+REGISTER_PASS(conv_transpose_bias_mkldnn_fuse_pass,
+              paddle::framework::ir::Conv2DTransposeBiasFusePass);
+REGISTER_PASS_CAPABILITY(conv_transpose_bias_mkldnn_fuse_pass)
+    .AddCombination(
+        paddle::framework::compatible::OpVersionComparatorCombination()
+            .EQ("conv2d_transpose", 0)
+            .EQ("elementwise_add", 0));
+
+REGISTER_PASS(conv3d_bias_mkldnn_fuse_pass,
+              paddle::framework::ir::Conv3DBiasFusePass);

paddle/fluid/framework/ir/mkldnn/cpu_bfloat16_placement_pass_tester.cc

@@ -44,6 +44,8 @@ void SetOp(ProgramDesc* prog, const std::string& type, const std::string& name,
     op->SetInput("X", {inputs[0]});
   } else if (type == "reshape2") {
     op->SetInput("X", {inputs[0]});
+  } else if (type == "sum") {
+    op->SetInput("X", {inputs[0], inputs[1]});
   } else {
     FAIL() << "Unexpected operator type.";
   }
@@ -61,8 +63,9 @@ void SetOp(ProgramDesc* prog, const std::string& type, const std::string& name,
 ProgramDesc BuildProgramDesc() {
   ProgramDesc prog;
 
-  for (auto& v : std::vector<std::string>(
-           {"a", "b", "c", "f", "g", "h", "k", "l", "m", "n", "o", "p"})) {
+  for (auto& v :
+       std::vector<std::string>({"a", "b", "c", "f", "g", "h", "k", "l", "m",
+                                 "n", "o", "p", "r", "s"})) {
     prog.MutableBlock(0)->Var(v);
   }
 
@@ -75,6 +78,7 @@ ProgramDesc BuildProgramDesc() {
   SetOp(&prog, "concat", "concat2", {"l", "m"}, {"n"});
   SetOp(&prog, "transpose2", "transpose", {"n"}, {"o"});
   SetOp(&prog, "reshape2", "reshape", {"o"}, {"p"});
+  SetOp(&prog, "sum", "sum", {"p", "r"}, {"s"});
 
   return prog;
 }
@@ -122,15 +126,15 @@ void DefaultAttrTest(unsigned expected_bfloat16_data_type_count) {
 }
 
 TEST(Bfloat16PlacementPass, enable_all) {
-  MainTest({"conv2d", "pool2d", "relu", "concat"}, 7);
+  MainTest({"conv2d", "pool2d", "relu", "concat", "sum"}, 8);
 }
 
 TEST(Bfloat16PlacementPass, enabled_conv_and_pool) {
   // 2 conv2d + 2 pool2 - 1 orphaned conv2d
   MainTest({"conv2d", "pool2d"}, 3);
 }
 
-TEST(Bfloat16PlacementPass, default_attr_value) { DefaultAttrTest(5); }
+TEST(Bfloat16PlacementPass, default_attr_value) { DefaultAttrTest(6); }
 
 }  // namespace ir
 }  // namespace framework

paddle/fluid/framework/op_version_registry.cc

@@ -13,3 +13,75 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #include "paddle/fluid/framework/op_version_registry.h"
+
+namespace paddle {
+namespace framework {
+namespace compatible {
+
+namespace {
+template <OpUpdateType type__, typename InfoType>
+OpUpdate<InfoType, type__>* new_update(InfoType&& info) {
+  return new OpUpdate<InfoType, type__>(info);
+}
+}
+
+OpVersionDesc&& OpVersionDesc::ModifyAttr(const std::string& name,
+                                          const std::string& remark,
+                                          const OpAttrVariantT& default_value) {
+  infos_.emplace_back(new_update<OpUpdateType::kModifyAttr>(
+      OpAttrInfo(name, remark, default_value)));
+  return std::move(*this);
+}
+
+OpVersionDesc&& OpVersionDesc::NewAttr(const std::string& name,
+                                       const std::string& remark,
+                                       const OpAttrVariantT& default_value) {
+  infos_.emplace_back(new_update<OpUpdateType::kNewAttr>(
+      OpAttrInfo(name, remark, default_value)));
+  return std::move(*this);
+}
+
+OpVersionDesc&& OpVersionDesc::NewInput(const std::string& name,
+                                        const std::string& remark) {
+  infos_.emplace_back(
+      new_update<OpUpdateType::kNewInput>(OpInputOutputInfo(name, remark)));
+  return std::move(*this);
+}
+
+OpVersionDesc&& OpVersionDesc::NewOutput(const std::string& name,
+                                         const std::string& remark) {
+  infos_.emplace_back(
+      new_update<OpUpdateType::kNewOutput>(OpInputOutputInfo(name, remark)));
+  return std::move(*this);
+}
+
+OpVersionDesc&& OpVersionDesc::BugfixWithBehaviorChanged(
+    const std::string& remark) {
+  infos_.emplace_back(new_update<OpUpdateType::kBugfixWithBehaviorChanged>(
+      OpBugfixInfo(remark)));
+  return std::move(*this);
+}
+
+OpVersion& OpVersionRegistrar::Register(const std::string& op_type) {
+  PADDLE_ENFORCE_EQ(
+      op_version_map_.find(op_type), op_version_map_.end(),
+      platform::errors::AlreadyExists(
+          "'%s' is registered in operator version more than once.", op_type));
+  op_version_map_.insert(
+      std::pair<std::string, OpVersion>{op_type, OpVersion()});
+  return op_version_map_[op_type];
+}
+uint32_t OpVersionRegistrar::version_id(const std::string& op_type) const {
+  PADDLE_ENFORCE_NE(
+      op_version_map_.count(op_type), 0,
+      platform::errors::InvalidArgument(
+          "The version of operator type %s has not been registered.", op_type));
+  return op_version_map_.find(op_type)->second.version_id();
+}
+
+// Provide a fake registration item for pybind testing.
+#include "paddle/fluid/framework/op_version_registry.inl"
+
+}  // namespace compatible
+}  // namespace framework
+}  // namespace paddle