PaddlePaddle
diff --git a/‎paddle/fluid/operators/collective/alltoall_op.cu.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎paddle/fluid/operators/collective/alltoall_op.cu.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎paddle/fluid/operators/collective/barrier_op.cu.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎paddle/fluid/operators/collective/barrier_op.cu.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
diff --git a/‎paddle/fluid/operators/collective/c_allgather_op.cu.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions b/‎paddle/fluid/operators/collective/c_allgather_op.cu.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions
diff --git a/‎paddle/fluid/operators/collective/c_allreduce_op.h
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎paddle/fluid/operators/collective/c_allreduce_op.h
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
diff --git a/‎paddle/fluid/operators/collective/c_broadcast_op.cu.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/operators/collective/c_broadcast_op.cu.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/fluid/operators/collective/c_concat_op.cu.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions b/‎paddle/fluid/operators/collective/c_concat_op.cu.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions
diff --git a/‎paddle/fluid/operators/collective/c_gen_nccl_id_op.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/fluid/operators/collective/c_gen_nccl_id_op.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/fluid/operators/collective/c_reduce_op.h
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions b/‎paddle/fluid/operators/collective/c_reduce_op.h
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions
diff --git a/‎paddle/fluid/operators/collective/c_reducescatter_op.cu.cc
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions b/‎paddle/fluid/operators/collective/c_reducescatter_op.cu.cc
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions
diff --git a/‎paddle/fluid/operators/collective/c_scatter_op.cu.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/operators/collective/c_scatter_op.cu.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
@@ -114,15 +114,15 @@ class AllToAllOpCUDAKernel : public framework::OpKernel<T> {
       comm_ctx->GroupEnd();
       VLOG(3) << "new comm_context_manager has rid " << ring_id;
     } else {
-      PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclGroupStart());
+      PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclGroupStart());
       for (auto i = 0; i < nranks; ++i) {
-        PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclSend(
+        PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclSend(
             send_buf + offset, send_numel, dtype, i, comm->comm(), stream));
-        PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclRecv(
+        PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclRecv(
             recv_buf + offset, send_numel, dtype, i, comm->comm(), stream));
         offset += send_numel;
       }
-      PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclGroupEnd());
+      PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclGroupEnd());
       VLOG(3) << "old NCCLCommContext has rid " << ring_id;
     }
 #else
 
@@ -71,13 +71,13 @@ class BarrierOpCUDAKernel : public framework::OpKernel<T> {
       // should ExecutionContext for calc stream.
       auto stream = ctx.cuda_device_context().stream();
       ncclRedOp_t nccl_red_type = ncclSum;
-      PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclAllReduce(sendbuff,
-                                                                  recvbuff,
-                                                                  numel,
-                                                                  dtype,
-                                                                  nccl_red_type,
-                                                                  comm->comm(),
-                                                                  stream));
+      PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclAllReduce(sendbuff,
+                                                             recvbuff,
+                                                             numel,
+                                                             dtype,
+                                                             nccl_red_type,
+                                                             comm->comm(),
+                                                             stream));
       platform::GpuStreamSync(stream);
       VLOG(3) << "old NCCLCommContext has rid " << rid;
     }
 
@@ -103,12 +103,12 @@ class CAllGatherOpCUDAKernel : public framework::OpKernel<T> {
       comm_ctx->AllGather(out, *in, stream);
     } else {
       PADDLE_ENFORCE_GPU_SUCCESS(
-          platform::dynload::ncclAllGather(send_buff,
-                                           recv_buff,
-                                           send_numel,
-                                           static_cast<ncclDataType_t>(dtype),
-                                           comm->comm(),
-                                           stream));
+          phi::dynload::ncclAllGather(send_buff,
+                                      recv_buff,
+                                      send_numel,
+                                      static_cast<ncclDataType_t>(dtype),
+                                      comm->comm(),
+                                      stream));
     }
 
 #else
 
@@ -427,13 +427,13 @@ class CAllReduceOpCUDAKernel : public framework::OpKernel<T> {
     if (comm_ctx) {
       comm_ctx->AllReduce(out, *in, nccl_red_type, stream);
     } else {
-      PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclAllReduce(sendbuff,
-                                                                  recvbuff,
-                                                                  numel,
-                                                                  dtype,
-                                                                  nccl_red_type,
-                                                                  comm->comm(),
-                                                                  stream));
+      PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclAllReduce(sendbuff,
+                                                             recvbuff,
+                                                             numel,
+                                                             dtype,
+                                                             nccl_red_type,
+                                                             comm->comm(),
+                                                             stream));
     }
 #else
     PADDLE_THROW(phi::errors::PreconditionNotMet(
 
@@ -54,7 +54,7 @@ class CBroadcastOpCUDAKernel : public framework::OpKernel<T> {
           platform::ToNCCLDataType(framework::TransToProtoVarType(x->dtype()));
       auto comm = platform::NCCLCommContext::Instance().Get(rid, place);
       if (root == comm->rank()) {
-        PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclBcast(
+        PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclBcast(
             reinterpret_cast<void*>(const_cast<T*>(x->data<T>())),
             numel,
             dtype,
@@ -71,7 +71,7 @@ class CBroadcastOpCUDAKernel : public framework::OpKernel<T> {
               static_cast<phi::DenseTensor*>(out));
         }
       } else {
-        PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclBcast(
+        PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclBcast(
             out->data<T>(), numel, dtype, root, comm->comm(), stream));
         VLOG(3) << "rank " << comm->rank() << " invoke Bcast. received "
                 << common::product(out->dims());
 
@@ -130,12 +130,12 @@ class CConcatOpCUDAKernel : public framework::OpKernel<T> {
         comm_ctx->AllGather(&temp_out, *x, stream);
       } else {
         PADDLE_ENFORCE_GPU_SUCCESS(
-            platform::dynload::ncclAllGather(send_buff,
-                                             recv_buff,
-                                             send_numel,
-                                             static_cast<ncclDataType_t>(dtype),
-                                             comm->comm(),
-                                             stream));
+            phi::dynload::ncclAllGather(send_buff,
+                                        recv_buff,
+                                        send_numel,
+                                        static_cast<ncclDataType_t>(dtype),
+                                        comm->comm(),
+                                        stream));
       }
     }
 
 
@@ -30,7 +30,7 @@ namespace operators {
 #if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
 static void GenNCCLID(std::vector<ncclUniqueId>* nccl_ids) {
   for (auto& nccl_id : *nccl_ids) {
-    PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclGetUniqueId(&nccl_id));
+    PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclGetUniqueId(&nccl_id));
   }
 }
 
 
@@ -321,14 +321,14 @@ class CReduceOpCUDAKernel : public framework::OpKernel<T> {
     if (comm_ctx) {
       comm_ctx->Reduce(out, *in, nccl_red_type, root, stream);
     } else {
-      PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclReduce(sendbuff,
-                                                               recvbuff,
-                                                               numel,
-                                                               dtype,
-                                                               nccl_red_type,
-                                                               root,
-                                                               comm->comm(),
-                                                               stream));
+      PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclReduce(sendbuff,
+                                                          recvbuff,
+                                                          numel,
+                                                          dtype,
+                                                          nccl_red_type,
+                                                          root,
+                                                          comm->comm(),
+                                                          stream));
     }
 #else
     PADDLE_ENFORCE_EQ(
 
@@ -107,14 +107,14 @@ class CReduceScatterOpCUDAKernel : public framework::OpKernel<T> {
     if (comm_ctx) {
       comm_ctx->ReduceScatter(out, *in, ncclSum, stream);
     } else {
-      PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclReduceScatter(
-          send_buff,
-          recv_buff,
-          recv_numel,
-          static_cast<ncclDataType_t>(dtype),
-          ncclSum,
-          comm->comm(),
-          stream));
+      PADDLE_ENFORCE_GPU_SUCCESS(
+          phi::dynload::ncclReduceScatter(send_buff,
+                                          recv_buff,
+                                          recv_numel,
+                                          static_cast<ncclDataType_t>(dtype),
+                                          ncclSum,
+                                          comm->comm(),
+                                          stream));
     }
 #else
     PADDLE_THROW(phi::errors::PreconditionNotMet(
 
@@ -123,7 +123,7 @@ class CScatterOpCUDAKernel : public framework::OpKernel<T> {
       }
     } else {
       if (root_id == comm->rank()) {
-        PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclBcast(
+        PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclBcast(
             reinterpret_cast<void*>(const_cast<T*>(x->data<T>())),
             numel,
             dtype,
@@ -137,7 +137,7 @@ class CScatterOpCUDAKernel : public framework::OpKernel<T> {
             *platform::DeviceContextPool::Instance().Get(place),
             static_cast<phi::DenseTensor*>(&temp));
       } else {
-        PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclBcast(
+        PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclBcast(
             out_ptr, numel, dtype, root_id, comm->comm(), stream));
       }
     }
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ namespace operators {`
`30`	`30`	`#if defined(PADDLE_WITH_NCCL) \|\| defined(PADDLE_WITH_RCCL)`
`31`	`31`	`static void GenNCCLID(std::vector<ncclUniqueId>* nccl_ids) {`
`32`	`32`	`for (auto& nccl_id : *nccl_ids) {`
`33`		`- PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclGetUniqueId(&nccl_id));`
	`33`	`+ PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclGetUniqueId(&nccl_id));`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ class CScatterOpCUDAKernel : public framework::OpKernel<T> {`
`123`	`123`	`}`
`124`	`124`	`} else {`
`125`	`125`	`if (root_id == comm->rank()) {`
`126`		`- PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclBcast(`
	`126`	`+ PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclBcast(`
`127`	`127`	`reinterpret_cast<void>(const_cast<T>(x->data<T>())),`
`128`	`128`	`numel,`
`129`	`129`	`dtype,`
`@@ -137,7 +137,7 @@ class CScatterOpCUDAKernel : public framework::OpKernel<T> {`
`137`	`137`	`*platform::DeviceContextPool::Instance().Get(place),`
`138`	`138`	`static_cast<phi::DenseTensor*>(&temp));`
`139`	`139`	`} else {`
`140`		`- PADDLE_ENFORCE_GPU_SUCCESS(platform::dynload::ncclBcast(`
	`140`	`+ PADDLE_ENFORCE_GPU_SUCCESS(phi::dynload::ncclBcast(`
`141`	`141`	`out_ptr, numel, dtype, root_id, comm->comm(), stream));`
`142`	`142`	`}`
`143`	`143`	`}`