Update portable op names to match functions.yaml (#1049)

Summary:
Pull Request resolved: #1049

- selected_op.yaml; contains *op_names* collected from the model
- dtype selective build; for each *op_name*, generate kernel code only if the dtype is used in the model

- this diff: make sure op_names in op_<op>.cpp file match the op name collected by selected_op.yaml. This is the op name from [functions.yaml](https://fburl.com/code/uok7njmb)

Note: the op names are not used for anything besides selective build, so this change should not break anything.

Reviewed By: manuelcandales

Differential Revision: D50425923

fbshipit-source-id: e91932d67be3bad1369f6065a02836abdd7490fd

Author: lucylq

kernels/portable/README.md

@@ -53,7 +53,7 @@ in other cases we can consider adding the missing features.
 
 ### Do your initial work in fbcode (skip this if in OSS)
 
-Althouth ExecuTorch is mapped into both `xplat` and `fbcode`, we recommend
+Although ExecuTorch is mapped into both `xplat` and `fbcode`, we recommend
 setting up the initial targets while working from `fbcode`. Once everything's in
 place, you should be able to build from either spot.
 

kernels/portable/cpu/op_abs.cpp

@@ -24,7 +24,7 @@ Tensor& abs_out(RuntimeContext& ctx, const Tensor& in, Tensor& out) {
   ET_CHECK_MSG(error == Error::Ok, "Failed to resize output tensor.");
   ET_CHECK_SAME_SHAPE_AND_DTYPE2(in, out);
 
-  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "abs", CTYPE, [&] {
+  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "abs.out", CTYPE, [&] {
     apply_unary_map_fn(
         [](const CTYPE val_in) {
           if (val_in < 0) {

kernels/portable/cpu/op_add.cpp

@@ -33,26 +33,28 @@ Tensor& add_out(
 
   ET_CHECK(canCast(common_type, out_type));
 
-  ET_SWITCH_REAL_TYPES_AND(Bool, a_type, ctx, "add", CTYPE_A, [&]() {
-    ET_SWITCH_REAL_TYPES_AND(Bool, b_type, ctx, "add", CTYPE_B, [&]() {
-      ET_SWITCH_REAL_TYPES_AND(Bool, common_type, ctx, "add", CTYPE_IN, [&]() {
-        ET_SWITCH_REAL_TYPES_AND(Bool, out_type, ctx, "add", CTYPE_OUT, [&]() {
-          CTYPE_IN alpha_val;
-          ET_EXTRACT_SCALAR(alpha, alpha_val);
-
-          apply_binary_elementwise_fn<CTYPE_A, CTYPE_B, CTYPE_OUT>(
-              [alpha_val](const CTYPE_A val_a, const CTYPE_B val_b) {
-                CTYPE_IN a_casted = static_cast<CTYPE_IN>(val_a);
-                CTYPE_IN b_casted = static_cast<CTYPE_IN>(val_b);
-                CTYPE_IN value = a_casted + alpha_val * b_casted;
-
-                return static_cast<CTYPE_OUT>(value);
-              },
-              a,
-              b,
-              out);
-        });
-      });
+  ET_SWITCH_REAL_TYPES_AND(Bool, a_type, ctx, "add.out", CTYPE_A, [&]() {
+    ET_SWITCH_REAL_TYPES_AND(Bool, b_type, ctx, "add.out", CTYPE_B, [&]() {
+      ET_SWITCH_REAL_TYPES_AND(
+          Bool, common_type, ctx, "add.out", CTYPE_IN, [&]() {
+            ET_SWITCH_REAL_TYPES_AND(
+                Bool, out_type, ctx, "add.out", CTYPE_OUT, [&]() {
+                  CTYPE_IN alpha_val;
+                  ET_EXTRACT_SCALAR(alpha, alpha_val);
+
+                  apply_binary_elementwise_fn<CTYPE_A, CTYPE_B, CTYPE_OUT>(
+                      [alpha_val](const CTYPE_A val_a, const CTYPE_B val_b) {
+                        CTYPE_IN a_casted = static_cast<CTYPE_IN>(val_a);
+                        CTYPE_IN b_casted = static_cast<CTYPE_IN>(val_b);
+                        CTYPE_IN value = a_casted + alpha_val * b_casted;
+
+                        return static_cast<CTYPE_OUT>(value);
+                      },
+                      a,
+                      b,
+                      out);
+                });
+          });
     });
   });
 
@@ -78,27 +80,29 @@ Tensor& add_scalar_out(
 
   ET_CHECK(common_type == out_type);
 
-  ET_SWITCH_REAL_TYPES_AND(Bool, a_type, ctx, "add", CTYPE_A, [&]() {
-    ET_SWITCH_SCALAR_OBJ_TYPES(b_type, ctx, "add", CTYPE_B, [&]() {
-      ET_SWITCH_REAL_TYPES_AND(Bool, common_type, ctx, "add", CTYPE_IN, [&]() {
-        ET_SWITCH_REAL_TYPES_AND(Bool, out_type, ctx, "add", CTYPE_OUT, [&]() {
-          CTYPE_B b_val;
-          ET_EXTRACT_SCALAR(b, b_val);
-          CTYPE_IN b_casted = static_cast<CTYPE_IN>(b_val);
-          CTYPE_IN alpha_val;
-          ET_EXTRACT_SCALAR(alpha, alpha_val);
-
-          apply_unary_map_fn(
-              [b_casted, alpha_val](const CTYPE_A val_a) {
-                CTYPE_IN a_casted = static_cast<CTYPE_IN>(val_a);
-                CTYPE_IN value = a_casted + alpha_val * b_casted;
-                return static_cast<CTYPE_OUT>(value);
-              },
-              a.const_data_ptr<CTYPE_A>(),
-              out.mutable_data_ptr<CTYPE_OUT>(),
-              out.numel());
-        });
-      });
+  ET_SWITCH_REAL_TYPES_AND(Bool, a_type, ctx, "add.Scalar_out", CTYPE_A, [&]() {
+    ET_SWITCH_SCALAR_OBJ_TYPES(b_type, ctx, "add.Scalar_out", CTYPE_B, [&]() {
+      ET_SWITCH_REAL_TYPES_AND(
+          Bool, common_type, ctx, "add.Scalar_out", CTYPE_IN, [&]() {
+            ET_SWITCH_REAL_TYPES_AND(
+                Bool, out_type, ctx, "add.Scalar_out", CTYPE_OUT, [&]() {
+                  CTYPE_B b_val;
+                  ET_EXTRACT_SCALAR(b, b_val);
+                  CTYPE_IN b_casted = static_cast<CTYPE_IN>(b_val);
+                  CTYPE_IN alpha_val;
+                  ET_EXTRACT_SCALAR(alpha, alpha_val);
+
+                  apply_unary_map_fn(
+                      [b_casted, alpha_val](const CTYPE_A val_a) {
+                        CTYPE_IN a_casted = static_cast<CTYPE_IN>(val_a);
+                        CTYPE_IN value = a_casted + alpha_val * b_casted;
+                        return static_cast<CTYPE_OUT>(value);
+                      },
+                      a.const_data_ptr<CTYPE_A>(),
+                      out.mutable_data_ptr<CTYPE_OUT>(),
+                      out.numel());
+                });
+          });
     });
   });
 

kernels/portable/cpu/op_addmm.cpp

@@ -47,9 +47,9 @@ Tensor& addmm_out(
 
   ScalarType alpha_dtype = utils::get_scalar_dtype(alpha);
   ScalarType beta_dtype = utils::get_scalar_dtype(beta);
-  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "addmm", CTYPE, [&]() {
-    ET_SWITCH_SCALAR_OBJ_TYPES(alpha_dtype, ctx, "addmm", ALPHA_T, [&]() {
-      ET_SWITCH_SCALAR_OBJ_TYPES(beta_dtype, ctx, "addmm", BETA_T, [&]() {
+  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "addmm.out", CTYPE, [&]() {
+    ET_SWITCH_SCALAR_OBJ_TYPES(alpha_dtype, ctx, "addmm.out", ALPHA_T, [&]() {
+      ET_SWITCH_SCALAR_OBJ_TYPES(beta_dtype, ctx, "addmm.out", BETA_T, [&]() {
         size_t m = mat1.size(0);
         size_t n = mat1.size(1);
         size_t p = mat2.size(1);

kernels/portable/cpu/op_amax.cpp

@@ -55,18 +55,19 @@ Tensor& amax_out(
   Error e = resize_reduction_out(in, dim_list, keepdim, out);
   ET_CHECK_MSG(e == Error::Ok, "Failed to resize out tensor in amax_out");
 
-  ET_SWITCH_REAL_TYPES_AND(Bool, in.scalar_type(), ctx, "amax", CTYPE, [&]() {
-    CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
-    for (size_t out_ix = 0; out_ix < out.numel(); ++out_ix) {
-      out_data[out_ix] = reduce_over_dim_list<CTYPE>(
-          [](CTYPE v, CTYPE max_v) {
-            return std::isnan(v) || v > max_v ? v : max_v;
-          },
-          in,
-          dim_list,
-          out_ix);
-    }
-  });
+  ET_SWITCH_REAL_TYPES_AND(
+      Bool, in.scalar_type(), ctx, "amax.out", CTYPE, [&]() {
+        CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
+        for (size_t out_ix = 0; out_ix < out.numel(); ++out_ix) {
+          out_data[out_ix] = reduce_over_dim_list<CTYPE>(
+              [](CTYPE v, CTYPE max_v) {
+                return std::isnan(v) || v > max_v ? v : max_v;
+              },
+              in,
+              dim_list,
+              out_ix);
+        }
+      });
 
   return out;
 }

kernels/portable/cpu/op_amin.cpp

@@ -55,18 +55,19 @@ Tensor& amin_out(
   Error e = resize_reduction_out(in, dim_list, keepdim, out);
   ET_CHECK_MSG(e == Error::Ok, "Failed to resize out tensor in amin_out");
 
-  ET_SWITCH_REAL_TYPES_AND(Bool, in.scalar_type(), ctx, "amin", CTYPE, [&]() {
-    CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
-    for (size_t out_ix = 0; out_ix < out.numel(); ++out_ix) {
-      out_data[out_ix] = reduce_over_dim_list<CTYPE>(
-          [](CTYPE v, CTYPE min_v) {
-            return std::isnan(v) || v < min_v ? v : min_v;
-          },
-          in,
-          dim_list,
-          out_ix);
-    }
-  });
+  ET_SWITCH_REAL_TYPES_AND(
+      Bool, in.scalar_type(), ctx, "amin.out", CTYPE, [&]() {
+        CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
+        for (size_t out_ix = 0; out_ix < out.numel(); ++out_ix) {
+          out_data[out_ix] = reduce_over_dim_list<CTYPE>(
+              [](CTYPE v, CTYPE min_v) {
+                return std::isnan(v) || v < min_v ? v : min_v;
+              },
+              in,
+              dim_list,
+              out_ix);
+        }
+      });
 
   return out;
 }

kernels/portable/cpu/op_any.cpp

@@ -24,18 +24,19 @@ Tensor& any_all_out(RuntimeContext& ctx, const Tensor& in, Tensor& out) {
   ScalarType in_type = in.scalar_type();
   ScalarType out_type = out.scalar_type();
 
-  ET_SWITCH_REAL_TYPES_AND(Bool, in_type, ctx, __func__, CTYPE_IN, [&] {
-    ET_SWITCH_TWO_TYPES(Bool, Byte, out_type, ctx, __func__, CTYPE_OUT, [&] {
-      const auto data_in = in.const_data_ptr<CTYPE_IN>();
-      auto data_out = out.mutable_data_ptr<CTYPE_OUT>();
-      data_out[0] = static_cast<CTYPE_OUT>(false);
-      for (auto i = 0; i < in.numel(); ++i) {
-        if (static_cast<CTYPE_OUT>(data_in[i])) {
-          data_out[0] = static_cast<CTYPE_OUT>(true);
-          break;
-        }
-      }
-    });
+  ET_SWITCH_REAL_TYPES_AND(Bool, in_type, ctx, "any.all_out", CTYPE_IN, [&] {
+    ET_SWITCH_TWO_TYPES(
+        Bool, Byte, out_type, ctx, "any.all_out", CTYPE_OUT, [&] {
+          const auto data_in = in.const_data_ptr<CTYPE_IN>();
+          auto data_out = out.mutable_data_ptr<CTYPE_OUT>();
+          data_out[0] = static_cast<CTYPE_OUT>(false);
+          for (auto i = 0; i < in.numel(); ++i) {
+            if (static_cast<CTYPE_OUT>(data_in[i])) {
+              data_out[0] = static_cast<CTYPE_OUT>(true);
+              break;
+            }
+          }
+        });
   });
 
   return out;

kernels/portable/cpu/op_arange.cpp

@@ -30,7 +30,7 @@ Tensor& arange_out(RuntimeContext& ctx, const Scalar& end, Tensor& out) {
   ScalarType end_type = utils::get_scalar_dtype(end);
 
   double end_val = 0;
-  ET_SWITCH_SCALAR_OBJ_TYPES(end_type, ctx, __func__, CTYPE_END, [&]() {
+  ET_SWITCH_SCALAR_OBJ_TYPES(end_type, ctx, "arange.out", CTYPE_END, [&]() {
     CTYPE_END end_v;
     ET_EXTRACT_SCALAR(end, end_v);
     ET_KERNEL_CHECK_MSG(
@@ -49,7 +49,7 @@ Tensor& arange_out(RuntimeContext& ctx, const Scalar& end, Tensor& out) {
   ET_KERNEL_CHECK_MSG(
       ctx, status == Error::Ok, InvalidArgument, out, "resize_tensor fails");
 
-  ET_SWITCH_REAL_TYPES(out.scalar_type(), ctx, __func__, CTYPE, [&]() {
+  ET_SWITCH_REAL_TYPES(out.scalar_type(), ctx, "arange.out", CTYPE, [&]() {
     auto out_data = out.mutable_data_ptr<CTYPE>();
     for (size_t i = 0; i < size; i++) {
       out_data[i] = static_cast<CTYPE>(i);
@@ -72,25 +72,28 @@ Tensor& arange_start_out(
   ScalarType step_type = utils::get_scalar_dtype(step);
 
   double d_start = 0;
-  ET_SWITCH_SCALAR_OBJ_TYPES(start_type, ctx, __func__, CTYPE_END, [&]() {
-    CTYPE_END start_v;
-    ET_EXTRACT_SCALAR(start, start_v);
-    d_start = static_cast<double>(start_v);
-  });
+  ET_SWITCH_SCALAR_OBJ_TYPES(
+      start_type, ctx, "arange.start_out", CTYPE_END, [&]() {
+        CTYPE_END start_v;
+        ET_EXTRACT_SCALAR(start, start_v);
+        d_start = static_cast<double>(start_v);
+      });
 
   double d_end = 0;
-  ET_SWITCH_SCALAR_OBJ_TYPES(end_type, ctx, __func__, CTYPE_END, [&]() {
-    CTYPE_END end_v;
-    ET_EXTRACT_SCALAR(end, end_v);
-    d_end = static_cast<double>(end_v);
-  });
+  ET_SWITCH_SCALAR_OBJ_TYPES(
+      end_type, ctx, "arange.start_out", CTYPE_END, [&]() {
+        CTYPE_END end_v;
+        ET_EXTRACT_SCALAR(end, end_v);
+        d_end = static_cast<double>(end_v);
+      });
 
   double d_step = 0;
-  ET_SWITCH_SCALAR_OBJ_TYPES(step_type, ctx, __func__, CTYPE_END, [&]() {
-    CTYPE_END step_v;
-    ET_EXTRACT_SCALAR(step, step_v);
-    d_step = static_cast<double>(step_v);
-  });
+  ET_SWITCH_SCALAR_OBJ_TYPES(
+      step_type, ctx, "arange.start_out", CTYPE_END, [&]() {
+        CTYPE_END step_v;
+        ET_EXTRACT_SCALAR(step, step_v);
+        d_step = static_cast<double>(step_v);
+      });
 
   ET_KERNEL_CHECK_MSG(
       ctx,
@@ -107,12 +110,13 @@ Tensor& arange_start_out(
   ET_KERNEL_CHECK_MSG(
       ctx, status == Error::Ok, InvalidArgument, out, "resize_tensor fails");
 
-  ET_SWITCH_REAL_TYPES(out.scalar_type(), ctx, __func__, CTYPE, [&]() {
-    auto out_data = out.mutable_data_ptr<CTYPE>();
-    for (size_t i = 0; i < size; i++) {
-      out_data[i] = convert<CTYPE, double>(d_start + i * d_step);
-    }
-  });
+  ET_SWITCH_REAL_TYPES(
+      out.scalar_type(), ctx, "arange.start_out", CTYPE, [&]() {
+        auto out_data = out.mutable_data_ptr<CTYPE>();
+        for (size_t i = 0; i < size; i++) {
+          out_data[i] = convert<CTYPE, double>(d_start + i * d_step);
+        }
+      });
 
   return out;
 }

kernels/portable/cpu/op_argmax.cpp

@@ -63,7 +63,7 @@ Tensor& argmax_out(
   Error error = resize_reduction_out(in, dim, keepdim, out);
   ET_CHECK_MSG(error == Error::Ok, "Failed to resize out tensor in argmax_out");
 
-  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "argmax", CTYPE, [&] {
+  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "argmax.out", CTYPE, [&] {
     long* out_data = out.mutable_data_ptr<long>();
 
     for (size_t out_ix = 0; out_ix < out.numel(); ++out_ix) {

kernels/portable/cpu/op_argmin.cpp

@@ -63,7 +63,7 @@ Tensor& argmin_out(
   Error error = resize_reduction_out(in, dim, keepdim, out);
   ET_CHECK_MSG(error == Error::Ok, "Failed to resize out tensor in argmin_out");
 
-  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "argmin", CTYPE, [&] {
+  ET_SWITCH_REAL_TYPES(in.scalar_type(), ctx, "argmin.out", CTYPE, [&] {
     long* out_data = out.mutable_data_ptr<long>();
 
     for (size_t out_ix = 0; out_ix < out.numel(); ++out_ix) {

kernels/portable/cpu/op_avg_pool2d.cpp

@@ -62,7 +62,7 @@ Tensor& avg_pool2d_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  ET_SWITCH_FLOAT_TYPES_AND(Long, in_type, ctx, __func__, CTYPE, [&]() {
+  ET_SWITCH_FLOAT_TYPES_AND(Long, in_type, ctx, "avg_pool2d.out", CTYPE, [&]() {
     if (divisor_override.has_value()) {
       int64_t divisor = divisor_override.value();
       // If divisor_override is specified, then we don't need to use `count` in