Non-fatal error when ET_SWITCH encounters unsupported dtype

manuelcandales · facebook-github-bot · commit ca35dd96df99 · 2025-08-12T19:33:00.000-07:00
Summary: Modify `ET_INTERNAL_SWITCH` macro, so that we fail non-fatally in the default clause when we encounter an unsupported dtype.

Differential Revision: D80141272
diff --git a/kernels/optimized/cpu/op_add_sub_impl.h b/kernels/optimized/cpu/op_add_sub_impl.h
@@ -144,13 +144,13 @@ Tensor& opt_add_sub_out_impl(
   } else if (selected_optimized_path != ElementwiseOptimizedPath::kNone) {
     // Cannot apply the trick of -alpha here because alpha is Scalar without
     // support for - operator. At least not right now.
-    ET_SWITCH_REALB_TYPES(out_type, ctx, op_name, CTYPE, [&]() {
+    ET_SWITCH_REALB_TYPES(out_type, ctx, op_name, CTYPE, [&]() -> void {
       CTYPE alpha_val;
       ET_KERNEL_CHECK_MSG(
           ctx,
           torch::executor::native::utils::extract_scalar(alpha, &alpha_val),
           InvalidArgument,
-          out,
+          ,
           "Failed to extract scalar alpha.");
       using Vec = at::vec::Vectorized<CTYPE>;
       Vec alpha_val_vec(alpha_val);
@@ -164,13 +164,13 @@ Tensor& opt_add_sub_out_impl(
           auto add_lambda = [&alpha_val_vec](auto x, auto y) {
             return y - alpha_val_vec * x;
           };
-          return torch::executor::handle_broadcast_elementwise<CTYPE>(
+          torch::executor::handle_broadcast_elementwise<CTYPE>(
               ctx, add_lambda, a, b, out, selected_optimized_path, alpha);
         } else {
           auto add_lambda = [&alpha_val_vec](auto x, auto y) {
             return x - alpha_val_vec * y;
           };
-          return torch::executor::handle_broadcast_elementwise<CTYPE>(
+          torch::executor::handle_broadcast_elementwise<CTYPE>(
               ctx, add_lambda, a, b, out, selected_optimized_path, alpha);
         }
       } else {
@@ -191,13 +191,13 @@ Tensor& opt_add_sub_out_impl(
           auto add_lambda = [&alpha_val_vec](auto x, auto y) {
             return y + alpha_val_vec * x;
           };
-          return torch::executor::handle_broadcast_elementwise<CTYPE>(
+          torch::executor::handle_broadcast_elementwise<CTYPE>(
               ctx, add_lambda, a, b, out, selected_optimized_path, alpha);
         } else {
           auto add_lambda = [&alpha_val_vec](auto x, auto y) {
             return x + alpha_val_vec * y;
           };
-          return torch::executor::handle_broadcast_elementwise<CTYPE>(
+          torch::executor::handle_broadcast_elementwise<CTYPE>(
               ctx, add_lambda, a, b, out, selected_optimized_path, alpha);
         }
       }
diff --git a/kernels/optimized/cpu/op_div.cpp b/kernels/optimized/cpu/op_div.cpp
@@ -130,11 +130,11 @@ Tensor& opt_div_out(
           selected_optimized_path ==
               ElementwiseOptimizedPath::kBroadcastNdByNdReverseArguments) {
         auto div_lambda = [](auto x, auto y) { return y / x; };
-        return torch::executor::handle_broadcast_elementwise<CTYPE>(
+        torch::executor::handle_broadcast_elementwise<CTYPE>(
             ctx, div_lambda, a, b, out, selected_optimized_path);
       } else {
         auto div_lambda = [](auto x, auto y) { return x / y; };
-        return torch::executor::handle_broadcast_elementwise<CTYPE>(
+        torch::executor::handle_broadcast_elementwise<CTYPE>(
             ctx, div_lambda, a, b, out, selected_optimized_path);
       }
     });
diff --git a/kernels/optimized/cpu/op_le.cpp b/kernels/optimized/cpu/op_le.cpp
@@ -57,7 +57,7 @@ Tensor& opt_le_tensor_out(
     // Handle optimized broadcast cases
     ET_SWITCH_REALB_TYPES(out_type, ctx, "le.Tensor_out", CTYPE, [&]() {
       auto le_lambda = [](auto x, auto y) { return x.le(y); };
-      return torch::executor::handle_broadcast_elementwise<CTYPE>(
+      torch::executor::handle_broadcast_elementwise<CTYPE>(
           ctx, le_lambda, a, b, out, selected_optimized_path);
     });
   } else {
diff --git a/kernels/optimized/cpu/op_mul.cpp b/kernels/optimized/cpu/op_mul.cpp
@@ -148,13 +148,13 @@ Tensor& opt_mul_out(
 
       ET_SWITCH_COMPLEXH_TYPES(out_type, ctx, "mul.out", CTYPE, [&]() {
         auto mul_lambda = [](auto x, auto y) { return x * y; };
-        return torch::executor::handle_broadcast_elementwise<CTYPE>(
+        torch::executor::handle_broadcast_elementwise<CTYPE>(
             ctx, mul_lambda, a, b, out, selected_optimized_path);
       });
     } else {
       ET_SWITCH_REALB_TYPES(out_type, ctx, "mul.out", CTYPE, [&]() {
         auto mul_lambda = [](auto x, auto y) { return x * y; };
-        return torch::executor::handle_broadcast_elementwise<CTYPE>(
+        torch::executor::handle_broadcast_elementwise<CTYPE>(
             ctx, mul_lambda, a, b, out, selected_optimized_path);
       });
     }
diff --git a/kernels/portable/cpu/op_clamp.cpp b/kernels/portable/cpu/op_clamp.cpp
@@ -34,6 +34,7 @@ bool is_out_of_bounds(CTYPE_CAST val_cast) {
 }
 
 ET_NODISCARD bool check_bounds(
+    KernelRuntimeContext& ctx,
     const Scalar& val_scalar,
     const torch::executor::native::ScalarType& val_type,
     const torch::executor::native::ScalarType& out_type,
@@ -104,14 +105,14 @@ Tensor& clamp_out(
   if (has_min) {
     ET_KERNEL_CHECK(
         ctx,
-        check_bounds(min_opt.value(), min_type, out_type, "minimum"),
+        check_bounds(ctx, min_opt.value(), min_type, out_type, "minimum"),
         InvalidArgument,
         out);
   }
   if (has_max) {
     ET_KERNEL_CHECK(
         ctx,
-        check_bounds(max_opt.value(), max_type, out_type, "maximum"),
+        check_bounds(ctx, max_opt.value(), max_type, out_type, "maximum"),
         InvalidArgument,
         out);
   }
diff --git a/kernels/portable/cpu/op_convolution.cpp b/kernels/portable/cpu/op_convolution.cpp
@@ -415,7 +415,7 @@ Tensor& convolution_out(
   ET_SWITCH_REALH_TYPES(in.scalar_type(), ctx, name, CTYPE, [&]() {
     const auto load_bias = bias.has_value()
         ? utils::internal::get_load_to_compute_fn<CTYPE, name>(
-              bias.value(), utils::SupportedTensorDtypes::REALHBF16)
+              ctx, bias.value(), utils::SupportedTensorDtypes::REALHBF16)
         : nullptr;
     convolution_wrapper<CTYPE>(
         in,
diff --git a/kernels/portable/cpu/op_cumsum.cpp b/kernels/portable/cpu/op_cumsum.cpp
@@ -111,10 +111,10 @@ Tensor& cumsum_out(
   // @lint-ignore CLANGTIDY facebook-hte-CArray
   static constexpr const char op_name[] = "cumsum.out";
 
-  ET_SWITCH_REALHBBF16_TYPES(out.scalar_type(), ctx, op_name, CTYPE_OUT, [&] {
+  ET_SWITCH_REALHBBF16_TYPES(out.scalar_type(), ctx, op_name, CTYPE_OUT, [&]() {
     const auto load_self =
         utils::internal::get_load_to_compute_fn<CTYPE_OUT, op_name>(
-            self, utils::SupportedTensorDtypes::REALHBBF16);
+            ctx, self, utils::SupportedTensorDtypes::REALHBBF16);
     cumsum_tensors<CTYPE_OUT>(self, load_self, dim, out);
   });
 
diff --git a/kernels/portable/cpu/op_index_put.cpp b/kernels/portable/cpu/op_index_put.cpp
@@ -160,6 +160,7 @@ Tensor& index_put_out(
 namespace {
 
 bool check_special_case_in_place_args(
+    KernelRuntimeContext& ctx,
     Tensor& in,
     TensorOptList indices,
     const Tensor& values,
@@ -285,7 +286,7 @@ Tensor& index_put_(
   size_t dim = 0;
   ET_KERNEL_CHECK(
       ctx,
-      check_special_case_in_place_args(in, indices, values, accumulate, &dim),
+      check_special_case_in_place_args(ctx, in, indices, values, accumulate, &dim),
       InvalidArgument,
       in);
 
diff --git a/kernels/portable/cpu/op_scatter.cpp b/kernels/portable/cpu/op_scatter.cpp
@@ -104,22 +104,20 @@ void scatter_value_helper(
 } // namespace
 
 Tensor& scatter_src_out(
-    KernelRuntimeContext& context,
+    KernelRuntimeContext& ctx,
     const Tensor& in,
     int64_t dim,
     const Tensor& index,
     const Tensor& src,
     Tensor& out) {
-  (void)context;
-
   ET_KERNEL_CHECK(
-      context,
+      ctx,
       check_scatter_src_args(in, dim, index, src, out),
       InvalidArgument,
       out);
 
   ET_KERNEL_CHECK(
-      context,
+      ctx,
       resize_tensor(out, in.sizes()) == Error::Ok,
       InvalidArgument,
       out);
diff --git a/kernels/portable/cpu/op_scatter_add.cpp b/kernels/portable/cpu/op_scatter_add.cpp
@@ -52,35 +52,33 @@ void scatter_add_helper(
 } // namespace
 
 Tensor& scatter_add_out(
-    KernelRuntimeContext& context,
+    KernelRuntimeContext& ctx,
     const Tensor& self,
     int64_t dim,
     const Tensor& index,
     const Tensor& src,
     Tensor& out) {
-  (void)context;
-
   ET_KERNEL_CHECK(
-      context,
+      ctx,
       check_scatter_add_args(self, dim, index, src, out),
       InvalidArgument,
       out);
 
   ET_KERNEL_CHECK(
-      context,
+      ctx,
       tensors_have_same_dim_order(self, src, out),
       InvalidArgument,
       out);
 
   ET_KERNEL_CHECK(
-      context, tensor_is_default_dim_order(index), InvalidArgument, out);
+      ctx, tensor_is_default_dim_order(index), InvalidArgument, out);
 
   if (dim < 0) {
     dim += nonzero_dim(self);
   }
 
   ET_KERNEL_CHECK(
-      context,
+      ctx,
       resize_tensor(out, self.sizes()) == Error::Ok,
       InvalidArgument,
       out);
diff --git a/kernels/portable/cpu/util/dtype_util.h b/kernels/portable/cpu/util/dtype_util.h
diff --git a/kernels/portable/cpu/util/elementwise_util.h b/kernels/portable/cpu/util/elementwise_util.h
diff --git a/runtime/core/exec_aten/util/scalar_type_util.h b/runtime/core/exec_aten/util/scalar_type_util.h
