PaddlePaddle
diff --git a/‎paddle/fluid/distributed/collective/process_group_custom.cc
Copy file name to clipboard
+5-6Lines changed: 5 additions & 6 deletions b/‎paddle/fluid/distributed/collective/process_group_custom.cc
Copy file name to clipboard
+5-6Lines changed: 5 additions & 6 deletions
diff --git a/‎paddle/fluid/imperative/xccl_context.cc
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions b/‎paddle/fluid/imperative/xccl_context.cc
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions
diff --git a/‎paddle/fluid/operators/custom_device_common_op_registry.cc
Copy file name to clipboard
+10-10Lines changed: 10 additions & 10 deletions b/‎paddle/fluid/operators/custom_device_common_op_registry.cc
Copy file name to clipboard
+10-10Lines changed: 10 additions & 10 deletions
diff --git a/‎paddle/phi/backends/c_comm_lib.h
Copy file name to clipboard
-56Lines changed: 0 additions & 56 deletions b/‎paddle/phi/backends/c_comm_lib.h
Copy file name to clipboard
-56Lines changed: 0 additions & 56 deletions
@@ -236,7 +236,7 @@ std::shared_ptr<ProcessGroup::Task> ProcessGroupCustom::AllToAll(
 
         std::vector<void*> send_buf, recv_buf;
         std::vector<size_t> send_count, recv_count;
-        std::vector<phi::ccl::CCLDataType> send_dtype, recv_dtype;
+        std::vector<phi::DataType> send_dtype, recv_dtype;
         for (auto i = 0; i < size_; i++) {
           in_numel = in_size_each_rank[i] * in_row_size;
           input_partial = GetPartialTensor(tensor_tmp, in_offset, in_numel);
@@ -248,8 +248,8 @@ std::shared_ptr<ProcessGroup::Task> ProcessGroupCustom::AllToAll(
           recv_buf.push_back(output_partial.data());
           send_count.push_back(in_numel);
           recv_count.push_back(out_numel);
-          send_dtype.push_back(phi::ccl::ToCCLDataType(input_partial.dtype()));
-          recv_dtype.push_back(phi::ccl::ToCCLDataType(output_partial.dtype()));
+          send_dtype.push_back(input_partial.dtype());
+          recv_dtype.push_back(output_partial.dtype());
         }
 
         phi::DeviceManager::CCLAllToAll(
@@ -992,9 +992,8 @@ std::shared_ptr<ProcessGroup::Task> ProcessGroupCustom::AllToAll(
         std::vector<void*> send_buf, recv_buf;
         std::vector<size_t> send_count(size_, input.numel() / size_),
             recv_count(size_, input.numel() / size_);
-        std::vector<phi::ccl::CCLDataType> send_dtype(
-            size_, phi::ccl::ToCCLDataType(input.dtype())),
-            recv_dtype(size_, phi::ccl::ToCCLDataType(input.dtype()));
+        std::vector<phi::DataType> send_dtype(size_, input.dtype()),
+            recv_dtype(size_, input.dtype());
         for (auto i = 0; i < size_; i++) {
           send_buf.push_back(
               GetPointerByOffset(input.data(), offset, input.dtype()));
 
@@ -50,13 +50,12 @@ static void XcclAllReduce(const phi::DenseTensor &src,
   auto *dst_ptr = phi::DeviceContextPool::Instance()
                       .Get(src.place())
                       ->Alloc(dst, src.dtype());
-  auto xccl_dtype = phi::ccl::ToCCLDataType(src.dtype());
 
   phi::DeviceManager::CCLAllReduce(place.GetDeviceType(),
                                    src_ptr,
                                    dst_ptr,
                                    src.numel(),
-                                   xccl_dtype,
+                                   src.dtype(),
                                    phi::ccl::CCLReduceOp::SUM,
                                    comm,
                                    stream);
@@ -201,12 +200,11 @@ void XCCLParallelContext::Broadcast(framework::Variable *src, int ring_id) {
   auto stream = comm->stream();
 
   void *src_ptr = src_tensor->data();
-  auto xccl_dtype = phi::ccl::ToCCLDataType(src_tensor->dtype());
 
   phi::DeviceManager::CCLBroadcast(place_.GetDeviceType(),
                                    src_ptr,
                                    src_tensor->numel(),
-                                   xccl_dtype,
+                                   src_tensor->dtype(),
                                    0,
                                    comm->comm(),
                                    *stream);
 
@@ -120,7 +120,7 @@ class CConcatOpCustomDeviceKernel : public framework::OpKernel<T> {
           reinterpret_cast<void*>(const_cast<T*>(send_buff)),
           recv_buff,
           send_numel,
-          phi::ccl::ToCCLDataType(x->dtype()),
+          x->dtype(),
           comm->GetXcclComm(),
           stream);
     }
@@ -560,7 +560,7 @@ class CAllReduceOpCustomDeviceKernel : public framework::OpKernel<T> {
     int rid = ctx.Attr<int>("ring_id");
 
     auto place = ctx.GetPlace();
-    auto dtype = phi::ccl::ToCCLDataType(in->dtype());
+    auto dtype = in->dtype();
     int64_t numel = in->numel();
     const void* sendbuff = in->data<T>();
     out->Resize(in->dims());
@@ -651,7 +651,7 @@ class CBroadcastOpCustomDeviceKernel : public framework::OpKernel<T> {
     }
 
     int numel = x->numel();
-    auto dtype = phi::ccl::ToCCLDataType(x->dtype());
+    auto dtype = x->dtype();
     if (root == comm->GetRank()) {
       phi::DeviceManager::CCLBroadcast(place.GetDeviceType(),
                                        const_cast<void*>(x->data()),
@@ -712,7 +712,7 @@ class BarrierOpCustomDeviceKernel : public framework::OpKernel<T> {
                                      const_cast<void*>(sendbuff),
                                      recvbuff,
                                      numel,
-                                     phi::ccl::ToCCLDataType(in->dtype()),
+                                     in->dtype(),
                                      phi::ccl::CCLReduceOp::SUM,
                                      comm->GetXcclComm(),
                                      *stream);
@@ -1059,7 +1059,7 @@ class GlobalScatterOpCustomDeviceKernel : public framework::OpKernel<T> {
                 place.GetDeviceType(),
                 reinterpret_cast<void*>(recv_buf + recv_ptr * in_feat),
                 cpu_global_count_data[idx] * in_feat,
-                phi::ccl::ToCCLDataType(x->dtype()),
+                x->dtype(),
                 j,
                 comm->GetXcclComm(),
                 *stream);
@@ -1075,7 +1075,7 @@ class GlobalScatterOpCustomDeviceKernel : public framework::OpKernel<T> {
                   const_cast<void*>(reinterpret_cast<const void*>(
                       send_buf + expert_ptr[idx] * in_feat)),
                   cpu_local_count_data[idx] * in_feat,
-                  phi::ccl::ToCCLDataType(x->dtype()),
+                  x->dtype(),
                   j,
                   comm->GetXcclComm(),
                   *stream);
@@ -1098,7 +1098,7 @@ class GlobalScatterOpCustomDeviceKernel : public framework::OpKernel<T> {
                 place.GetDeviceType(),
                 reinterpret_cast<void*>(recv_buf + recv_ptr * in_feat),
                 cpu_global_count_data[idx] * in_feat,
-                phi::ccl::ToCCLDataType(x->dtype()),
+                x->dtype(),
                 j,
                 comm->GetXcclComm(),
                 *stream);
@@ -1269,7 +1269,7 @@ class GlobalGatherOpCustomDeviceKernel : public framework::OpKernel<T> {
             phi::DeviceManager::CCLRecv(place.GetDeviceType(),
                                         recv_buf + expert_ptr[idx] * in_feat,
                                         cpu_local_count_data[idx] * in_feat,
-                                        phi::ccl::ToCCLDataType(x->dtype()),
+                                        x->dtype(),
                                         j,
                                         comm->GetXcclComm(),
                                         *stream);
@@ -1284,7 +1284,7 @@ class GlobalGatherOpCustomDeviceKernel : public framework::OpKernel<T> {
                   const_cast<void*>(reinterpret_cast<const void*>(
                       send_buf + send_ptr * in_feat)),
                   cpu_global_count_data[idx] * in_feat,
-                  phi::ccl::ToCCLDataType(x->dtype()),
+                  x->dtype(),
                   j,
                   comm->GetXcclComm(),
                   *stream);
@@ -1305,7 +1305,7 @@ class GlobalGatherOpCustomDeviceKernel : public framework::OpKernel<T> {
             phi::DeviceManager::CCLRecv(place.GetDeviceType(),
                                         recv_buf + expert_ptr[idx] * in_feat,
                                         cpu_local_count_data[idx] * in_feat,
-                                        phi::ccl::ToCCLDataType(x->dtype()),
+                                        x->dtype(),
                                         j,
                                         comm->GetXcclComm(),
                                         *stream);
 
@@ -29,17 +29,6 @@ typedef void* CCLComm;
 typedef std::vector<uint8_t> CCLRootId;
 
 enum CCLReduceOp { SUM = 0, AVG, MAX, MIN, PRODUCT };
-enum CCLDataType {
-  CCL_DATA_TYPE_FP64 = 0,
-  CCL_DATA_TYPE_FP32,
-  CCL_DATA_TYPE_FP16,
-  CCL_DATA_TYPE_BF16,
-  CCL_DATA_TYPE_INT64,
-  CCL_DATA_TYPE_INT32,
-  CCL_DATA_TYPE_INT16,
-  CCL_DATA_TYPE_INT8,
-  CCL_DATA_TYPE_UINT8
-};
 
 inline CCLReduceOp ToXCCLReduceOp(int reduce_type) {
   phi::ccl::CCLReduceOp red_type = phi::ccl::CCLReduceOp::SUM;
@@ -67,51 +56,6 @@ inline CCLReduceOp ToXCCLReduceOp(int reduce_type) {
   return red_type;
 }
 
-inline CCLDataType ToCCLDataType(phi::DataType type) {
-  if (type == phi::DataType::FLOAT64) {
-    return CCL_DATA_TYPE_FP64;
-  } else if (type == phi::DataType::FLOAT32) {
-    return CCL_DATA_TYPE_FP32;
-  } else if (type == phi::DataType::FLOAT16) {
-    return CCL_DATA_TYPE_FP16;
-  } else if (type == phi::DataType::BFLOAT16) {
-    return CCL_DATA_TYPE_BF16;
-  } else if (type == phi::DataType::INT64) {
-    return CCL_DATA_TYPE_INT64;
-  } else if (type == phi::DataType::INT32) {
-    return CCL_DATA_TYPE_INT32;
-  } else if (type == phi::DataType::INT8) {
-    return CCL_DATA_TYPE_INT8;
-  } else if (type == phi::DataType::UINT8) {
-    return CCL_DATA_TYPE_UINT8;
-  } else {
-    PADDLE_THROW(
-        phi::errors::Unimplemented("This datatype %s in CCL is not supported.",
-                                   phi::DataTypeToString(type)));
-  }
-}
-
-inline phi::DataType ToPhiDataType(CCLDataType type) {
-  if (type == CCLDataType::CCL_DATA_TYPE_FP64) {
-    return phi::DataType::FLOAT64;
-  } else if (type == CCLDataType::CCL_DATA_TYPE_FP32) {
-    return phi::DataType::FLOAT32;
-  } else if (type == CCLDataType::CCL_DATA_TYPE_FP16) {
-    return phi::DataType::FLOAT16;
-  } else if (type == CCLDataType::CCL_DATA_TYPE_BF16) {
-    return phi::DataType::BFLOAT16;
-  } else if (type == CCLDataType::CCL_DATA_TYPE_INT64) {
-    return phi::DataType::INT64;
-  } else if (type == CCLDataType::CCL_DATA_TYPE_INT32) {
-    return phi::DataType::INT32;
-  } else if (type == CCLDataType::CCL_DATA_TYPE_INT8) {
-    return phi::DataType::INT8;
-  } else {
-    PADDLE_THROW(
-        phi::errors::Unimplemented("This datatype in CCL is not supported."));
-  }
-}
-
 inline std::string SerializeXCCLUniqueId(const phi::ccl::CCLRootId& ccl_id) {
   const uint8_t* bytes = ccl_id.data();
   std::ostringstream oss;