[arm][kernel]fix: broadcast dim fix logic updated test=develop (#4859)

* [arm][kernel]fix: broadcast dim fix logic updated test=develop

* fix: use VLOG(4) test=develop

* fix: update broadcast test when x.dim.size smaller test=develop

Author: edimetia3d

lite/kernels/arm/elementwise_compute.cc

@@ -54,13 +54,13 @@ inline bool is_fast_broadcast(const DDim& x_dims,
     axis = x_dims.size() - y_dims.size();
   }
   if (axis < 0) {
-    LOG(INFO) << "Fast broadcast chk fail, for x_dims smaller.";
+    VLOG(4) << "Fast broadcast chk fail, for x_dims smaller.";
     return false;
   }
   DDim y_dim_trim = trim_trailing_singular_dims(y_dims);
   axis = (y_dim_trim.size() == 0) ? x_dims.size() : axis;
   if (x_dims.size() == y_dim_trim.size()) {
-    LOG(INFO)
+    VLOG(4)
         << "Fast broadcast chk fail, for y's shape not really contained in x";
     return false;
   }
@@ -72,7 +72,7 @@ inline bool is_fast_broadcast(const DDim& x_dims,
   }
   for (int i = 0; i < y_dim_trim.size(); ++i) {
     if (x_dims[i + axis] != y_dim_trim[i]) {
-      LOG(WARNING) << "Fast broadcast chk fail, for dimension mismatch.";
+      VLOG(4) << "Fast broadcast chk fail, for dimension mismatch.";
       return false;
     }
     (*n) *= y_dim_trim[i];
@@ -151,10 +151,6 @@ void elementwise_compute_template(paddle::lite::KernelBase* kernel,
   auto& param = kernel->template Param<OpParamType>();
   auto x = param.X;
   auto y = param.Y;
-  if (opd_swap_able == OprandSwapable::YES &&
-      x->dims().size() < y->dims().size()) {
-    std::swap(x, y);
-  }
 
   auto* x_data = x->template data<T>();
   auto* y_data = y->template data<T>();

lite/kernels/host/elementwise_op_func.h

@@ -271,7 +271,7 @@ void BatchElementWiseArg<Elem_t, DimValue_t>::Update(
     BroadcastType broadcast_type) {
   // arg checking
   if (broadcast_type == BroadcastType::UNKNOWN) {
-    LOG(INFO) << "No broadcast type input";
+    VLOG(4) << "No broadcast type input";
     broadcast_type = get_broadcast_type(x_dims, y_dims, dim_size);
   }
   if (broadcast_type == BroadcastType::UNKNOWN ||
@@ -281,7 +281,7 @@ void BatchElementWiseArg<Elem_t, DimValue_t>::Update(
   }
   if (broadcast_type == BroadcastType::SAME_DIM) {
     broadcast_type = BroadcastType::BOTH_CONTINUOUS;
-    LOG(INFO) << "Same dim detected";
+    VLOG(4) << "Same dim detected";
     // SAME_DIM should not be treated as broadcast. For SAME_DIM is a special
     // case of BOTH_CONTINUOUS, we could still process it.
   }
@@ -492,13 +492,25 @@ void fix_x_y_dims(const Tensor *X,
     }
   } else {
     if (X->dims().size() != Out->dims().size()) {
-      LOG(FATAL) << "X and OUT dim size mismatch";
-    }
-    for (int i = 0; i < out_dim_size; ++i) {
-      x_dims[i] = X->dims()[i];
-    }
-    for (int i = axis; i < out_dim_size; ++i) {
-      y_dims[i + axis] = Y->dims()[i];
+      if (Y->dims().size() != Out->dims().size()) {
+        LOG(FATAL) << "X/Y and OUT dim size mismatch";
+      } else {
+        VLOG(4) << "Arguments broke API reference, for X.dims().size() is "
+                   "smaller and axis is set";
+        for (int i = 0; i < out_dim_size; ++i) {
+          y_dims[i] = Y->dims()[i];
+        }
+        for (int i = 0; i < X->dims().size(); ++i) {
+          x_dims[i + axis] = X->dims()[i];
+        }
+      }
+    } else {
+      for (int i = 0; i < out_dim_size; ++i) {
+        x_dims[i] = X->dims()[i];
+      }
+      for (int i = 0; i < Y->dims().size(); ++i) {
+        y_dims[i + axis] = Y->dims()[i];
+      }
     }
   }
 }

lite/tests/kernels/elementwise_common_broadcast_test.cc

@@ -168,13 +168,13 @@ class ElementwiseComputeTester : public arena::TestCase {
   void PrepareData() override {
     std::vector<T> dx(x_dims_.production());
     for (size_t i = 0; i < dx.size(); i++) {
-      dx[i] = i;
+      dx[i] = 1;
     }
     SetCommonTensor(x_, x_dims_, dx.data());
 
     std::vector<T> dy(y_dims_.production());
     for (size_t i = 0; i < dy.size(); i++) {
-      dy[i] = 2 * i + 1;
+      dy[i] = 1;
     }
     SetCommonTensor(y_, y_dims_, dy.data());
   }
@@ -204,10 +204,12 @@ bool RunOnRandomArgs(const Place& place,
   std::vector<int> y_dim_cut;
 
   int axis = -1;
-  bool cut_dimension = randbool();
+  static bool cut_dimension = true;
+  cut_dimension = !cut_dimension;
   if (cut_dimension) {
     // generate x_dim_cut and y_dim_cut by remove dimension
-    bool use_axis = randbool();
+    static bool use_axis = true;
+    use_axis = !use_axis;
     if (use_axis) {
       x_dim_cut = x_dim_full;
       // we will cut y only, and set tail of y to be 1
@@ -225,6 +227,12 @@ bool RunOnRandomArgs(const Place& place,
       for (int i = dim_size - tail1_num; i < dim_size; ++i) {
         y_dim_full[i] = 1;
       }
+      static bool swap_x_and_y = true;
+      swap_x_and_y = !swap_x_and_y;
+      if (swap_x_and_y) {
+        std::swap(x_dim_cut, y_dim_cut);
+        std::swap(x_dim_full, y_dim_full);
+      }
     } else {
       // we will cut x or y
       if (randbool()) {
@@ -301,7 +309,7 @@ bool RunOnRandomArgs(const Place& place,
 #ifdef LITE_WITH_ARM
 
 TEST(elementwise_broadcast, compute_fp32) {
-  const int TEST_RETEAT_NUM = 5;
+  const int TEST_RETEAT_NUM = 10;
   for (int repeat_count = 0; repeat_count < TEST_RETEAT_NUM; ++repeat_count) {
     EXPECT_TRUE(paddle::lite::RunOnRandomArgs<float>(
         TARGET(kARM), "def", "add", "", [](float l, float r) {
@@ -323,7 +331,7 @@ TEST(elementwise_broadcast, compute_fp32) {
 }
 
 TEST(elementwise_broadcast, compute_i32) {
-  const int TEST_RETEAT_NUM = 5;
+  const int TEST_RETEAT_NUM = 10;
   for (int repeat_count = 0; repeat_count < TEST_RETEAT_NUM; ++repeat_count) {
     EXPECT_TRUE(paddle::lite::RunOnRandomArgs<int32_t>(
         paddle::lite::Place(TARGET(kARM), PRECISION(kInt32)),