Update base for Update on "[ET][Portable][Build Size] Integer division binary ops: floor_divide, fmod, remainder"

- remainder:      386 K -> 15 K
- fmod:               317 K -> 14 K
- floor_divide:    255 K -> 11 K

Differential Revision: [D63909727](https://our.internmc.facebook.com/intern/diff/D63909727/)

[ghstack-poisoned]

Author: manuelcandales

kernels/portable/cpu/op_div.cpp

@@ -133,7 +133,8 @@ Tensor& div_out_mode(
           if (mode_is_trunc) {
             value = std::trunc(value);
           } else  {
-            // We established above that the mode is either trunc or floor, so it must be floor.
+            // We established above that the mode is either trunc or floor, so
+            // it must be floor.
             value = utils::floor_divide(val_a, val_b);
           }
           return value;
@@ -185,9 +186,7 @@ Tensor& div_scalar_out(
   ET_SWITCH_FLOAT_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
     const CTYPE_COMPUTE val_b = utils::scalar_to<CTYPE_COMPUTE>(b);
     utils::apply_unitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
-        [val_b](const CTYPE_COMPUTE val_a) {
-          return val_a / val_b;
-        },
+        [val_b](const CTYPE_COMPUTE val_a) {return val_a / val_b;},
         ctx,
         a,
         utils::SupportedTensorDtypes::REALHBBF16,

kernels/portable/cpu/op_mul.cpp

@@ -43,6 +43,12 @@ Tensor& mul_out(
 
   static constexpr const char op_name[] = "mul.out";
 
+  ET_KERNEL_CHECK(
+      ctx,
+      (executorch::runtime::isRealType(compute_type) || compute_type == ScalarType::Bool),
+      InvalidArgument,
+      out);
+
   ET_SWITCH_REALB_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
     utils::apply_bitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
         [](const CTYPE_COMPUTE val_a, const CTYPE_COMPUTE val_b) {
@@ -87,9 +93,7 @@ Tensor& mul_scalar_out(
   ET_SWITCH_REALB_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
     const CTYPE_COMPUTE val_b = utils::scalar_to<CTYPE_COMPUTE>(b);
     utils::apply_unitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
-        [val_b](const CTYPE_COMPUTE val_a) {
-          return val_a * val_b;
-        },
+        [val_b](const CTYPE_COMPUTE val_a) {return val_a * val_b;},
         ctx,
         a,
         utils::SupportedTensorDtypes::REALHBBF16,

kernels/portable/cpu/op_pow.cpp

@@ -103,9 +103,7 @@ Tensor& pow_Tensor_Scalar_out(
   ET_SWITCH_FLOAT_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
     const CTYPE_COMPUTE val_b = utils::scalar_to<CTYPE_COMPUTE>(b);
     utils::apply_unitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
-        [val_b](const CTYPE_COMPUTE val_a) {
-          return std::pow(val_a, val_b);
-        },
+        [val_b](const CTYPE_COMPUTE val_a) {return std::pow(val_a, val_b);},
         ctx,
         a,
         utils::SupportedTensorDtypes::REALHBBF16,
@@ -151,9 +149,7 @@ Tensor& pow_Scalar_out(
   ET_SWITCH_FLOAT_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
     const CTYPE_COMPUTE val_a = utils::scalar_to<CTYPE_COMPUTE>(a);
     utils::apply_unitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
-        [val_a](const CTYPE_COMPUTE val_b) {
-          return std::pow(val_a, val_b);
-        },
+        [val_a](const CTYPE_COMPUTE val_b) {return std::pow(val_a, val_b);},
         ctx,
         b,
         utils::SupportedTensorDtypes::REALHBBF16,

kernels/portable/cpu/op_rsub.cpp

@@ -53,7 +53,6 @@ Tensor& rsub_scalar_out(
     const CTYPE_COMPUTE val_alpha = utils::scalar_to<CTYPE_COMPUTE>(alpha);
     utils::apply_unitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
         [val_b, val_alpha](const CTYPE_COMPUTE val_a) {
-
           return val_b - val_alpha * val_a;
         },
         ctx,

kernels/portable/test/op_mul_test.cpp

@@ -49,12 +49,14 @@ TEST_F(OpMulOutKernelTest, UnhandledDtypeDies) {
   std::vector<exec_aten::qint8> b_data(a_data);
   std::vector<exec_aten::qint8> out_data(a_data);
 
+  std::vector<exec_aten::DimOrderType> dim_order = {0, 1};
+
   auto a_impl = torch::executor::TensorImpl(
-      ScalarType::QInt8, 2, sizes.data(), a_data.data());
+      ScalarType::QInt8, 2, sizes.data(), a_data.data(), dim_order.data());
   auto b_impl = torch::executor::TensorImpl(
-      ScalarType::QInt8, 2, sizes.data(), b_data.data());
+      ScalarType::QInt8, 2, sizes.data(), b_data.data(), dim_order.data());
   auto out_impl = torch::executor::TensorImpl(
-      ScalarType::QInt8, 2, sizes.data(), out_data.data());
+      ScalarType::QInt8, 2, sizes.data(), out_data.data(), dim_order.data());
 
   // Two input tensors.
   Tensor a(&a_impl);