20230321

cmake/cblas.cmake

@@ -96,6 +96,7 @@ if(NOT DEFINED CBLAS_PROVIDER)
         STATUS
           "Found OpenBLAS (include: ${OPENBLAS_INC_DIR}, library: ${CBLAS_LIBRARIES})"
       )
+
       message(
         STATUS "Found lapack in OpenBLAS (include: ${OPENBLAS_LAPACKE_INC_DIR})"
       )

cmake/phi_header.cmake

@@ -51,3 +51,6 @@ phi_header_path_compat(
 file(RENAME
      ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/extension.h
      ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/ext_all.h)
+# Included header file of training and inference can be unified as single file: paddle/extension.h
+file(COPY ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/include/experimental/ext_all.h
+     DESTINATION ${PADDLE_INFERENCE_INSTALL_DIR}/paddle/extension.h)

paddle/fluid/distributed/collective/process_group_custom.cc

@@ -219,20 +219,20 @@ std::shared_ptr<ProcessGroup::Task> ProcessGroupCustom::Collective(
 
 void* XcclGetPointerByOffset(void* raw_pointer,
                              size_t offset,
-                             experimental::DataType type) {
-  if (type == experimental::DataType::FLOAT32) {
+                             phi::DataType type) {
+  if (type == phi::DataType::FLOAT32) {
     return reinterpret_cast<void*>(reinterpret_cast<float*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::FLOAT64) {
+  } else if (type == phi::DataType::FLOAT64) {
     return reinterpret_cast<void*>(reinterpret_cast<double*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::INT32) {
+  } else if (type == phi::DataType::INT32) {
     return reinterpret_cast<void*>(reinterpret_cast<int32_t*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::INT64) {
+  } else if (type == phi::DataType::INT64) {
     return reinterpret_cast<void*>(reinterpret_cast<int64_t*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::FLOAT16) {
+  } else if (type == phi::DataType::FLOAT16) {
     return reinterpret_cast<void*>(reinterpret_cast<int16_t*>(raw_pointer) +
                                    offset);
   } else {

paddle/fluid/distributed/collective/process_group_gloo.cc

@@ -39,19 +39,19 @@ namespace distributed {
 #ifdef _WIN32
 #define GENERATE_FUNC(type, func, ...)       \
   switch (type) {                            \
-    case experimental::DataType::FLOAT32:    \
+    case phi::DataType::FLOAT32:             \
       func<float>(__VA_ARGS__);              \
       break;                                 \
-    case experimental::DataType::FLOAT64:    \
+    case phi::DataType::FLOAT64:             \
       func<double>(__VA_ARGS__);             \
       break;                                 \
-    case experimental::DataType::FLOAT16:    \
+    case phi::DataType::FLOAT16:             \
       func<gloo::float16>(__VA_ARGS__);      \
       break;                                 \
-    case experimental::DataType::INT32:      \
+    case phi::DataType::INT32:               \
       func<int32_t>(__VA_ARGS__);            \
       break;                                 \
-    case experimental::DataType::INT64:      \
+    case phi::DataType::INT64:               \
       func<int64_t>(__VA_ARGS__);            \
       break;                                 \
     default:                                 \
@@ -64,31 +64,31 @@ namespace distributed {
 #else
 #define GENERATE_FUNC(type, func, args...)   \
   switch (type) {                            \
-    case experimental::DataType::FLOAT32:    \
+    case phi::DataType::FLOAT32:             \
       func<float>(args);                     \
       break;                                 \
-    case experimental::DataType::FLOAT64:    \
+    case phi::DataType::FLOAT64:             \
       func<double>(args);                    \
       break;                                 \
-    case experimental::DataType::FLOAT16:    \
+    case phi::DataType::FLOAT16:             \
       func<gloo::float16>(args);             \
       break;                                 \
-    case experimental::DataType::INT32:      \
+    case phi::DataType::INT32:               \
       func<int32_t>(args);                   \
       break;                                 \
-    case experimental::DataType::INT64:      \
+    case phi::DataType::INT64:               \
       func<int64_t>(args);                   \
       break;                                 \
-    case experimental::DataType::INT8:       \
+    case phi::DataType::INT8:                \
       func<int8_t>(args);                    \
       break;                                 \
-    case experimental::DataType::UINT8:      \
+    case phi::DataType::UINT8:               \
       func<uint8_t>(args);                   \
       break;                                 \
-    case experimental::DataType::BOOL:       \
+    case phi::DataType::BOOL:                \
       func<bool>(args);                      \
       break;                                 \
-    case experimental::DataType::BFLOAT16:   \
+    case phi::DataType::BFLOAT16:            \
       func<bfloat16>(args);                  \
       break;                                 \
     default:                                 \
@@ -285,7 +285,7 @@ class AllreduceGlooTask : public ProcessGroupGloo::GlooTask {
   const ReduceOp _reduce_op;
   uint32_t _tag;
 
-  gloo::AllreduceOptions::Func _get_function(const experimental::DataType type,
+  gloo::AllreduceOptions::Func _get_function(const phi::DataType type,
                                              const ReduceOp op) {
     gloo::AllreduceOptions::Func fn;
     GENERATE_FUNC(type, _get_function_impl, fn, op);
@@ -457,7 +457,7 @@ class ReduceGlooTask : public ProcessGroupGloo::GlooTask {
   int _dst;
   uint32_t _tag;
 
-  gloo::ReduceOptions::Func _get_function(const experimental::DataType type,
+  gloo::ReduceOptions::Func _get_function(const phi::DataType type,
                                           const ReduceOp op) {
     gloo::ReduceOptions::Func fn;
     GENERATE_FUNC(type, _get_function_impl, fn, op);

paddle/fluid/distributed/collective/process_group_nccl.cc

@@ -993,34 +993,32 @@ std::shared_ptr<ProcessGroup::Task> ProcessGroupNCCL::AllGather(
       CommType::ALLGATHER);
 }
 
-void* GetPointerByOffset(void* raw_pointer,
-                         size_t offset,
-                         experimental::DataType type) {
-  if (type == experimental::DataType::FLOAT32) {
+void* GetPointerByOffset(void* raw_pointer, size_t offset, phi::DataType type) {
+  if (type == phi::DataType::FLOAT32) {
     return reinterpret_cast<void*>(reinterpret_cast<float*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::FLOAT64) {
+  } else if (type == phi::DataType::FLOAT64) {
     return reinterpret_cast<void*>(reinterpret_cast<double*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::FLOAT16) {
+  } else if (type == phi::DataType::FLOAT16) {
     return reinterpret_cast<void*>(reinterpret_cast<int16_t*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::INT32) {
+  } else if (type == phi::DataType::INT32) {
     return reinterpret_cast<void*>(reinterpret_cast<int32_t*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::INT64) {
+  } else if (type == phi::DataType::INT64) {
     return reinterpret_cast<void*>(reinterpret_cast<int64_t*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::INT8) {
+  } else if (type == phi::DataType::INT8) {
     return reinterpret_cast<void*>(reinterpret_cast<int8_t*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::UINT8) {
+  } else if (type == phi::DataType::UINT8) {
     return reinterpret_cast<void*>(reinterpret_cast<uint8_t*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::BOOL) {
+  } else if (type == phi::DataType::BOOL) {
     return reinterpret_cast<void*>(reinterpret_cast<bool*>(raw_pointer) +
                                    offset);
-  } else if (type == experimental::DataType::BFLOAT16) {
+  } else if (type == phi::DataType::BFLOAT16) {
     return reinterpret_cast<void*>(reinterpret_cast<uint16_t*>(raw_pointer) +
                                    offset);
   } else {

paddle/fluid/distributed/collective/reducer.cc

@@ -77,12 +77,11 @@ std::vector<std::vector<size_t>> Eager_AssignGroupBySize(
 
   // Key: the var type
   // Value: should use which index in group_size_limits for group size limit
-  std::map<experimental::DataType, size_t> group_limit_index;
+  std::map<phi::DataType, size_t> group_limit_index;
 
   // Key: the var type
   // Value: <the var index in input tensors, total numel in this group>
-  std::map<experimental::DataType, std::pair<std::vector<size_t>, size_t>>
-      next_group;
+  std::map<phi::DataType, std::pair<std::vector<size_t>, size_t>> next_group;
 
   for (size_t i = 0; i < tensors.size(); ++i) {
     const auto &var = tensors[i];
@@ -114,7 +113,7 @@ std::vector<std::vector<size_t>> Eager_AssignGroupBySize(
     }
 
     group_info.first.push_back(tensor_real_index);
-    group_info.second += experimental::SizeOf(var_dtype) * var_size;
+    group_info.second += phi::SizeOf(var_dtype) * var_size;
     // group_info.second += framework::SizeOfType(var_dtype) * var_size;
 
     if (group_limit_index.find(var_dtype) == group_limit_index.end()) {

paddle/fluid/eager/amp_auto_cast.h

@@ -21,7 +21,7 @@
 namespace egr {
 
 static inline bool NeedCast(const paddle::Tensor& tensor,
-                            const paddle::experimental::DataType& dst_dtype) {
+                            const phi::DataType& dst_dtype) {
   auto place = tensor.place();
   auto data_type = tensor.dtype();
   if (paddle::platform::is_gpu_place(place) ||
@@ -32,9 +32,9 @@ static inline bool NeedCast(const paddle::Tensor& tensor,
       paddle::platform::is_npu_pinned_place(place) ||
       paddle::platform::is_custom_place(place)) {
     // CudaPinndePlace is added for varbase created by dataloader
-    if ((data_type == paddle::experimental::DataType::FLOAT32 ||
-         data_type == paddle::experimental::DataType::FLOAT16 ||
-         data_type == paddle::experimental::DataType::BFLOAT16) &&
+    if ((data_type == phi::DataType::FLOAT32 ||
+         data_type == phi::DataType::FLOAT16 ||
+         data_type == phi::DataType::BFLOAT16) &&
         (data_type != dst_dtype)) {
       return true;
     }
@@ -45,7 +45,7 @@ static inline bool NeedCast(const paddle::Tensor& tensor,
 inline std::vector<paddle::Tensor> AmpAutoCasts(
     const std::string& inputs_name,
     const std::vector<paddle::Tensor>& inputs,
-    const paddle::experimental::DataType& dst_dtype,
+    const phi::DataType& dst_dtype,
     std::string op_name) {
   VLOG(6) << "AMP AmpAutoCasts:"
           << " inputs(" << inputs_name << ") dst_dtype("
@@ -65,15 +65,14 @@ inline std::vector<paddle::Tensor> AmpAutoCasts(
   return inputs_casted;
 }
 
-inline paddle::Tensor AmpAutoCast(
-    const std::string& input_name,
-    const paddle::Tensor& input,
-    const paddle::experimental::DataType& dst_dtype,
-    std::string op_name) {
+inline paddle::Tensor AmpAutoCast(const std::string& input_name,
+                                  const paddle::Tensor& input,
+                                  const phi::DataType& dst_dtype,
+                                  std::string op_name) {
   VLOG(6) << "AMP AmpAutoCasts:"
           << " input(" << input_name << ") dst_dtype("
           << phi::DataTypeToString(dst_dtype) << ").";
-  if (dst_dtype == paddle::experimental::DataType::FLOAT16) {
+  if (dst_dtype == phi::DataType::FLOAT16) {
     if (op_name == "run_program") {
       return input;
     }

paddle/fluid/eager/amp_utils.h

@@ -20,44 +20,41 @@
 
 namespace egr {
 
-static inline paddle::experimental::DataType GetPromoteType(
+static inline phi::DataType GetPromoteType(
     const std::string& op_name,
     const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& amp_tensors_vector,
-    const paddle::experimental::DataType& amp_dtype) {
+    const phi::DataType& amp_dtype) {
   auto dst_type = amp_dtype;
   if (egr::Controller::Instance().GetCurrentTracer()->GetAmpDtype() ==
       "float16") {
     if (op_name == "batch_norm" || op_name == "layer_norm" ||
         op_name == "sync_batch_norm") {
-      if (amp_tensors_vector[0][0].dtype() ==
-          paddle::experimental::DataType::FLOAT32) {
-        dst_type = paddle::experimental::DataType::FLOAT32;
+      if (amp_tensors_vector[0][0].dtype() == phi::DataType::FLOAT32) {
+        dst_type = phi::DataType::FLOAT32;
       }
     } else if (op_name == "fused_attention") {
       for (size_t i = 0; i < amp_tensors_vector.size(); i++) {
         if (i != 3 || i != 4 || i != 9 || i != 10) {
-          if (amp_tensors_vector[i][0].dtype() ==
-              paddle::experimental::DataType::FLOAT32) {
-            dst_type = paddle::experimental::DataType::FLOAT32;
+          if (amp_tensors_vector[i][0].dtype() == phi::DataType::FLOAT32) {
+            dst_type = phi::DataType::FLOAT32;
             break;
           }
         }
       }
     } else if (op_name == "fused_feedforward") {
       for (size_t i = 0; i < amp_tensors_vector.size(); i++) {
         if (i != 7 || i != 8 || i != 9 || i != 10) {
-          if (amp_tensors_vector[i][0].dtype() ==
-              paddle::experimental::DataType::FLOAT32) {
-            dst_type = paddle::experimental::DataType::FLOAT32;
+          if (amp_tensors_vector[i][0].dtype() == phi::DataType::FLOAT32) {
+            dst_type = phi::DataType::FLOAT32;
             break;
           }
         }
       }
     } else {
       for (const auto& tensors : amp_tensors_vector) {
         for (const auto& tensor : tensors) {
-          if (tensor.dtype() == paddle::experimental::DataType::FLOAT32) {
+          if (tensor.dtype() == phi::DataType::FLOAT32) {
             dst_type = tensor.dtype();
             break;
           }
@@ -67,7 +64,7 @@ static inline paddle::experimental::DataType GetPromoteType(
   } else {
     for (const auto& tensors : amp_tensors_vector) {
       for (const auto& tensor : tensors) {
-        if (tensor.dtype() == paddle::experimental::DataType::FLOAT32) {
+        if (tensor.dtype() == phi::DataType::FLOAT32) {
           dst_type = tensor.dtype();
           break;
         }
@@ -77,20 +74,19 @@ static inline paddle::experimental::DataType GetPromoteType(
   // NOTE(juncai): moving_average_abs_max_scale only consider the dtype of
   // input(X)
   if (op_name == "moving_average_abs_max_scale") {
-    if (amp_tensors_vector[0][0].dtype() ==
-        paddle::experimental::DataType::FLOAT16) {
-      dst_type = paddle::experimental::DataType::FLOAT16;
+    if (amp_tensors_vector[0][0].dtype() == phi::DataType::FLOAT16) {
+      dst_type = phi::DataType::FLOAT16;
     }
   }
   return dst_type;
 }
 
-inline paddle::experimental::DataType GetDtypeWithPlace(
+inline phi::DataType GetDtypeWithPlace(
     const std::string& op_name,
     const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& amp_tensors_vector,
-    const paddle::experimental::DataType amp_dtype) {
-  if (amp_dtype == paddle::experimental::DataType::FLOAT32) {
+    const phi::DataType amp_dtype) {
+  if (amp_dtype == phi::DataType::FLOAT32) {
     return amp_dtype;
   }
   bool is_right_place = false;
@@ -113,12 +109,12 @@ inline paddle::experimental::DataType GetDtypeWithPlace(
   if (!is_right_place) {
     VLOG(6) << "Change " << op_name << "'s AMP type from " << amp_dtype
             << " to FP32";
-    return paddle::experimental::DataType::FLOAT32;
+    return phi::DataType::FLOAT32;
   }
   return amp_dtype;
 }
 
-inline paddle::experimental::DataType GetAmpDestDtype(
+inline phi::DataType GetAmpDestDtype(
     const std::string& op_name,
     const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& amp_tensors_vector) {
@@ -134,23 +130,23 @@ inline paddle::experimental::DataType GetAmpDestDtype(
     } else if (paddle::imperative::AmpOperators::Instance()
                    .GetMutableBlockOps()
                    ->count(op_name)) {
-      dst_type = paddle::experimental::DataType::FLOAT32;
+      dst_type = phi::DataType::FLOAT32;
     } else {
       dst_type = GetPromoteType(op_name, amp_tensors_vector, amp_setting_dtype);
     }
   } else if (amp_level == paddle::imperative::AmpLevel::O2) {
     if (paddle::imperative::AmpOperators::Instance()
             .GetMutableBlockOps()
             ->count(op_name)) {
-      dst_type = paddle::experimental::DataType::FLOAT32;
+      dst_type = phi::DataType::FLOAT32;
     }
   }
 
   if (dst_type == amp_setting_dtype &&
       (paddle::imperative::AmpOperators::Instance()
            .GetMutableUnsupportedOps(amp_setting_dtype)
            ->count(op_name))) {
-    dst_type = paddle::experimental::DataType::FLOAT32;
+    dst_type = phi::DataType::FLOAT32;
   }
 
   dst_type = GetDtypeWithPlace(op_name, amp_tensors_vector, dst_type);

paddle/fluid/eager/auto_code_generator/generator/codegen_utils.py

@@ -91,7 +91,7 @@
     'bool[]': 'std::vector<bool>',
     'Place': 'paddle::Place',
     'DataLayout': 'phi::DataLayout',
-    'DataType': 'paddle::experimental::DataType',
+    'DataType': 'phi::DataType',
     'int64_t[]': 'std::vector<int64_t>',
     'int[]': 'std::vector<int>',
     'Tensor': 'Tensor',
@@ -293,8 +293,10 @@ def ParseYamlArgs(string):
         assert (
             arg_type in yaml_types_mapping.keys()
         ), f"The argument type {arg_type} in yaml config is not supported in yaml_types_mapping."
-        if arg_type in ["DataType", "DataLayout"] and default_value is not None:
+        if arg_type in ["DataLayout"] and default_value is not None:
             default_value = f"paddle::experimental::{default_value}"
+        if arg_type in ["DataType"] and default_value is not None:
+            default_value = f"phi::{default_value}"
         arg_type = yaml_types_mapping[arg_type]
 
         arg_name = RemoveSpecialSymbolsInName(arg_name)