Fix (#65390)

co63oc · web-flow · commit 1c44bcee8617 · 2024-06-24T15:26:32.000+08:00
diff --git a/paddle/fluid/operators/optimizers/distributed_fused_lamb_op.cu b/paddle/fluid/operators/optimizers/distributed_fused_lamb_op.cu
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/fluid/operators/optimizers/multi_tensor_apply.h"
 #include "paddle/fluid/platform/collective_helper.h"
+#include "paddle/phi/kernels/funcs/multi_tensor_apply_util.h"
 
 #include "paddle/phi/backends/context_pool.h"
 #include "paddle/phi/backends/gpu/gpu_launch_config.h"
@@ -214,21 +214,21 @@ static void MultiTensorL2Norm(const phi::GPUPlace &place,
   auto *tmp_out_ptr = tmp_out.Alloc<MT>(n * max_chunk_num);
   FillZeroWithPtr(tmp_out_ptr, n * max_chunk_num, stream);
 
-#define PD_LAUNCH_MULTI_TENSOR_APPLY_L2_NORM_KERNEL                       \
-  do {                                                                    \
-    using FunctorT = L2NormFunctor<InT, kBlockDim, kVecSize>;             \
-    VLOG(10) << __func__ << " " << typeid(InT).name()                     \
-             << " VecSize = " << kVecSize;                                \
-    paddle::operators::MultiTensorApply<FunctorT, kNumTensor, kNumChunk>( \
-        FunctorT(),                                                       \
-        stream,                                                           \
-        offsets,                                                          \
-        n,                                                                \
-        chunk_size,                                                       \
-        kBlockDim,                                                        \
-        x,                                                                \
-        tmp_out_ptr,                                                      \
-        max_chunk_num);                                                   \
+#define PD_LAUNCH_MULTI_TENSOR_APPLY_L2_NORM_KERNEL                \
+  do {                                                             \
+    using FunctorT = L2NormFunctor<InT, kBlockDim, kVecSize>;      \
+    VLOG(10) << __func__ << " " << typeid(InT).name()              \
+             << " VecSize = " << kVecSize;                         \
+    phi::funcs::MultiTensorApply<FunctorT, kNumTensor, kNumChunk>( \
+        FunctorT(),                                                \
+        stream,                                                    \
+        offsets,                                                   \
+        n,                                                         \
+        chunk_size,                                                \
+        kBlockDim,                                                 \
+        x,                                                         \
+        tmp_out_ptr,                                               \
+        max_chunk_num);                                            \
   } while (0)
 
   PD_VEC_LAUNCH_KERNEL(vec_size, PD_LAUNCH_MULTI_TENSOR_APPLY_L2_NORM_KERNEL);
@@ -870,22 +870,22 @@ static void MultiTensorUpdateLambParamAndBetaPows(
                     betapow_helper);                                     \
   } while (0)
 
-#define PD_LAUNCH_VEC_MULTI_TENSOR_UPDATE_PARAM_BETAPOW_CASE                   \
-  do {                                                                         \
-    auto callback =                                                            \
-        [&](const paddle::operators::MultiTensorLauncher<kNumTensor,           \
-                                                         kNumChunk> &launcher, \
-            int launch_n) {                                                    \
-          if (has_beta_pow && launch_n == 0) {                                 \
-            PD_LAUNCH_MULTI_TENSOR_UPDATE_PARAM_BETAPOW(true);                 \
-            beta1pow = nullptr;                                                \
-            beta2pow = nullptr;                                                \
-          } else {                                                             \
-            PD_LAUNCH_MULTI_TENSOR_UPDATE_PARAM_BETAPOW(false);                \
-          }                                                                    \
-        };                                                                     \
-    paddle::operators::MultiTensorApplyWithCallback<kNumTensor, kNumChunk>(    \
-        stream, offsets, n, chunk_size, block_dim, callback);                  \
+#define PD_LAUNCH_VEC_MULTI_TENSOR_UPDATE_PARAM_BETAPOW_CASE             \
+  do {                                                                   \
+    auto callback =                                                      \
+        [&](const phi::funcs::MultiTensorLauncher<kNumTensor, kNumChunk> \
+                &launcher,                                               \
+            int launch_n) {                                              \
+          if (has_beta_pow && launch_n == 0) {                           \
+            PD_LAUNCH_MULTI_TENSOR_UPDATE_PARAM_BETAPOW(true);           \
+            beta1pow = nullptr;                                          \
+            beta2pow = nullptr;                                          \
+          } else {                                                       \
+            PD_LAUNCH_MULTI_TENSOR_UPDATE_PARAM_BETAPOW(false);          \
+          }                                                              \
+        };                                                               \
+    phi::funcs::MultiTensorApplyWithCallback<kNumTensor, kNumChunk>(     \
+        stream, offsets, n, chunk_size, block_dim, callback);            \
   } while (0)
 
   PD_VEC_LAUNCH_KERNEL(vec_size,
diff --git a/paddle/phi/kernels/funcs/multi_tensor_apply_util.h b/paddle/phi/kernels/funcs/multi_tensor_apply_util.h
@@ -20,8 +20,8 @@
 
 #include "paddle/phi/core/cuda_stream.h"
 
-namespace paddle {
-namespace operators {
+namespace phi {
+namespace funcs {
 
 template <int MaxTensorNumPerLaunch, int MaxChunkNumPerLaunch>
 struct TensorMetaList {
@@ -216,5 +216,5 @@ static void MultiTensorApply(Functor functor,
       stream, offsets, n, chunk_size, block_dim, callback);
 }
 
-}  // namespace operators
-}  // namespace paddle
+}  // namespace funcs
+}  // namespace phi
