fix some log info error

Author: taixiurong

paddle/fluid/operators/amp/check_finite_and_unscale_op_xpu.cc

@@ -69,10 +69,11 @@ class CheckFiniteAndUnscaleXPUKernel : public framework::OpKernel<T> {
         r = xpu::logical_not(dev_ctx.x_context(), reinterpret_cast<const bool*>(
                                                       is_finite.data<bool>()),
                              is_finite.data<bool>(), x->numel());
-        PADDLE_ENFORCE_EQ(r, XPU_SUCCESS, platform::errors::External(
-                                              "XPU API(isfinite) return wrong "
-                                              "value[%d %s]",
-                                              r, XPUAPIErrorMsg[r]));
+        PADDLE_ENFORCE_EQ(
+            r, XPU_SUCCESS,
+            platform::errors::External("XPU API(logical_not) return wrong "
+                                       "value[%d %s]",
+                                       r, XPUAPIErrorMsg[r]));
         r = xpu::isnan(dev_ctx.x_context(),
                        reinterpret_cast<const XPUTyp*>(x->data<T>()),
                        is_nan.data<bool>(), x->numel());
@@ -83,10 +84,11 @@ class CheckFiniteAndUnscaleXPUKernel : public framework::OpKernel<T> {
         r = xpu::logical_or(dev_ctx.x_context(), is_finite.data<bool>(),
                             is_nan.data<bool>(), is_finite.data<bool>(),
                             x->numel());
-        PADDLE_ENFORCE_EQ(r, XPU_SUCCESS, platform::errors::External(
-                                              "XPU API(any) return wrong "
-                                              "value[%d %s]",
-                                              r, XPUAPIErrorMsg[r]));
+        PADDLE_ENFORCE_EQ(
+            r, XPU_SUCCESS,
+            platform::errors::External("XPU API(logical_or) return wrong "
+                                       "value[%d %s]",
+                                       r, XPUAPIErrorMsg[r]));
         r = xpu::any(dev_ctx.x_context(), is_finite.data<bool>(),
                      found_inf_data, x->numel());
         PADDLE_ENFORCE_EQ(r, XPU_SUCCESS, platform::errors::External(
@@ -135,6 +137,9 @@ class CheckFiniteAndUnscaleXPUKernel : public framework::OpKernel<T> {
                                               "XPU API(cast_v2) return wrong "
                                               "value[%d %s]",
                                               r, XPUAPIErrorMsg[r]));
+        if (dev_ctx.x_context()->xpu_stream) {
+          dev_ctx.Wait();
+        }
 
       } else {
         int r = xpu::scale(dev_ctx.x_context(),

paddle/fluid/operators/amp/update_loss_scaling_op_xpu.cc

@@ -58,11 +58,10 @@ class UpdateLossScalingXPUKernel : public framework::OpKernel<T> {
         r = xpu::constant(dev_ctx.x_context(),
                           reinterpret_cast<XPUTyp*>(out_data), num,
                           XPUTyp(0.0));
-        PADDLE_ENFORCE_EQ(r == xpu::Error_t::SUCCESS, true,
-                          platform::errors::External(
-                              "XPU API return wrong value[%d], please check "
-                              "where Baidu Kunlun Card is properly installed.",
-                              r));
+        PADDLE_ENFORCE_EQ(r, XPU_SUCCESS, platform::errors::External(
+                                              "XPU API(constant) return wrong "
+                                              "value[%d %s]",
+                                              r, XPUAPIErrorMsg[r]));
       }
     }
     const bool stop_update = ctx.Attr<bool>("stop_update");

paddle/fluid/operators/dropout_op_xpu.cc

@@ -118,25 +118,21 @@ class DropoutGradXPUKernel : public framework::OpKernel<T> {
                          reinterpret_cast<const XPUTyp*>(mask->data<T>()),
                          reinterpret_cast<XPUTyp*>(mask_new.data<T>()),
                          mask->numel(), false, scale, 0.0f);
-      PADDLE_ENFORCE_EQ(
-          r, xpu::Error_t::SUCCESS,
-          platform::errors::External(
-              "XPU dropout return wrong value[%d], please check whether "
-              "Baidu Kunlun Card is properly installed.",
-              r));
+      PADDLE_ENFORCE_EQ(r, XPU_SUCCESS, platform::errors::External(
+                                            "XPU API(scale) return wrong "
+                                            "value[%d %s]",
+                                            r, XPUAPIErrorMsg[r]));
       mask_data = mask_new.data<T>();
     }
 
     int r = xpu::mul(
         dev_ctx.x_context(), reinterpret_cast<const XPUTyp*>(grad_y->data<T>()),
         reinterpret_cast<const XPUTyp*>(mask_data),
         reinterpret_cast<XPUTyp*>(grad_x->data<T>()), grad_y->numel());
-    PADDLE_ENFORCE_EQ(
-        r, xpu::Error_t::SUCCESS,
-        platform::errors::External(
-            "XPU dropout return wrong value[%d], please check whether "
-            "Baidu Kunlun Card is properly installed.",
-            r));
+    PADDLE_ENFORCE_EQ(r, XPU_SUCCESS,
+                      platform::errors::External("XPU API(mul) return wrong "
+                                                 "value[%d %s]",
+                                                 r, XPUAPIErrorMsg[r]));
   }
 };
 }  // namespace operators

paddle/fluid/operators/elementwise/elementwise_add_op_xpu.cc

@@ -150,19 +150,22 @@ class ElementwiseAddGradXPUKernel : public ElemwiseGradKernel<T> {
     const T* dz_data = dz->data<T>();
     framework::Tensor dx_local_tensor;
     framework::Tensor dy_local_tensor;
+    bool need_wait = false;
     T* dx_data = nullptr;
     T* dy_data = nullptr;
     if (dx) {
       dx_data = dx->mutable_data<T>(ctx.GetPlace());
     } else {
       dx_data =
           dx_local_tensor.mutable_data<T>(ctx.GetPlace(), x_len * sizeof(T));
+      need_wait = true;
     }
     if (dy) {
       dy_data = dy->mutable_data<T>(ctx.GetPlace());
     } else {
       dy_data =
           dy_local_tensor.mutable_data<T>(ctx.GetPlace(), y_len * sizeof(T));
+      need_wait = true;
     }
 
     auto& dev_ctx =
@@ -175,6 +178,9 @@ class ElementwiseAddGradXPUKernel : public ElemwiseGradKernel<T> {
         platform::errors::External(
             "XPU kernel Elementwise occur error in XPUElementwise error code ",
             ret, XPUAPIErrorMsg[ret]));
+    if (need_wait && dev_ctx.x_context()->xpu_stream) {
+      dev_ctx.Wait();
+    }
   }
 };