msvc really hates constexpr variables I guess 2

JacobSzwejbka · JacobSzwejbka · commit bc71d1c4aee6 · 2025-10-18T12:00:31.000-07:00
diff --git a/kernels/optimized/cpu/op_bmm.cpp b/kernels/optimized/cpu/op_bmm.cpp
@@ -150,6 +150,7 @@ Tensor& opt_bmm_out(
   ET_KERNEL_CHECK(
       ctx, check_bmm_out_args(self, mat2, out), InvalidArgument, out);
 
+
   auto self_type = self.scalar_type();
 
   if (executorch::runtime::isComplexType(self_type)) {
diff --git a/kernels/portable/cpu/op_convolution_backward.cpp b/kernels/portable/cpu/op_convolution_backward.cpp
@@ -305,9 +305,7 @@ std::tuple<Tensor&, Tensor&, Tensor&> convolution_backward_out(
         ret_val);
   }
 
-  constexpr auto name = "convolution_backward.out";
-
-  ET_SWITCH_FLOATHBF16_TYPES(input.scalar_type(), ctx, name, CTYPE, [&]() {
+  ET_SWITCH_FLOATHBF16_TYPES(input.scalar_type(), ctx, "convolution_backward.out", CTYPE, [&]() {
     conv2d_backward_impl<CTYPE>(
         grad_output,
         input,
diff --git a/kernels/portable/cpu/op_gather.cpp b/kernels/portable/cpu/op_gather.cpp
@@ -85,9 +85,7 @@ Tensor& gather_out(
       InvalidArgument,
       out);
 
-  constexpr auto name = "gather.out";
-
-  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, name, CTYPE, [&]() {
+  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, "gather.out", CTYPE, [&]() {
     gather_helper<CTYPE>(in, index, out, dim);
   });
 
diff --git a/kernels/portable/cpu/op_max.cpp b/kernels/portable/cpu/op_max.cpp
@@ -124,10 +124,8 @@ max_unary_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 
   ET_KERNEL_CHECK(ctx, canCast(in_type, out_type), InvalidArgument, out);
 
-  constexpr auto name = "max.unary_out";
-
-  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, name, CTYPE_IN, [&] {
-    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, name, CTYPE_OUT, [&] {
+  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, "max.unary_out", CTYPE_IN, [&] {
+    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, "max.unary_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] = lower_bound<CTYPE_OUT>();
diff --git a/kernels/portable/cpu/op_max_pool2d_with_indices_backward.cpp b/kernels/portable/cpu/op_max_pool2d_with_indices_backward.cpp
@@ -169,9 +169,7 @@ Tensor& max_pool2d_with_indices_backward_out(
       InvalidArgument,
       grad_input);
 
-  constexpr auto name = "max_pool2d_with_indices_backward.grad_input";
-
-  ET_SWITCH_FLOATHBF16_TYPES(input.scalar_type(), ctx, name, CTYPE, [&]() {
+  ET_SWITCH_FLOATHBF16_TYPES(input.scalar_type(), ctx, "max_pool2d_with_indices_backward.grad_input", CTYPE, [&]() {
     max_pool_backward_impl<CTYPE, false>(grad_input, grad_output, indices);
   });
 
diff --git a/kernels/portable/cpu/op_min.cpp b/kernels/portable/cpu/op_min.cpp
@@ -124,10 +124,8 @@ min_unary_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 
   ET_KERNEL_CHECK(ctx, canCast(in_type, out_type), InvalidArgument, out);
 
-  constexpr auto name = "min.unary_out";
-
-  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, name, CTYPE_IN, [&] {
-    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, name, CTYPE_OUT, [&] {
+  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, "min.unary_out", CTYPE_IN, [&] {
+    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, "min.unary_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] = upper_bound<CTYPE_OUT>();
diff --git a/kernels/portable/cpu/op_native_batch_norm.cpp b/kernels/portable/cpu/op_native_batch_norm.cpp
@@ -102,9 +102,7 @@ std::tuple<Tensor&, Tensor&, Tensor&> _native_batch_norm_legit_no_training_out(
   size_t outer = getLeadingDims(in, C_dim);
   size_t inner = getTrailingDims(in, C_dim);
 
-  constexpr auto name = "native_batch_norm_legit_no_training.out";
-
-  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, name, CTYPE, [&] {
+  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, "native_batch_norm_legit_no_training.out", CTYPE, [&] {
     const CTYPE* in_data = in.const_data_ptr<CTYPE>();
     CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
 
@@ -259,9 +257,7 @@ std::tuple<Tensor&, Tensor&, Tensor&> _native_batch_norm_legit_no_stats_out(
       InvalidArgument,
       ret_val);
 
-  constexpr auto name = "_native_batch_norm_legit.no_stats_out";
-
-  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, name, CTYPE, [&] {
+  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, "_native_batch_norm_legit.no_stats_out", CTYPE, [&] {
     const CTYPE* in_data = in.const_data_ptr<CTYPE>();
     CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
     CTYPE* mean_data = mean_out.mutable_data_ptr<CTYPE>();
diff --git a/kernels/portable/cpu/op_native_group_norm.cpp b/kernels/portable/cpu/op_native_group_norm.cpp
@@ -190,9 +190,7 @@ std::tuple<Tensor&, Tensor&, Tensor&> native_group_norm_out(
         ret_val);
   }
 
-  constexpr auto name = "native_group_norm.out";
-
-  ET_SWITCH_FLOATHBF16_TYPES(input.scalar_type(), ctx, name, CTYPE, [&]() {
+  ET_SWITCH_FLOATHBF16_TYPES(input.scalar_type(), ctx, "native_group_norm.out", CTYPE, [&]() {
     group_norm<CTYPE>(
         input, weight, bias, N, C, HxW, group, eps, out, mean_out, rstd_out);
   });
diff --git a/kernels/portable/cpu/op_pdist_forward.cpp b/kernels/portable/cpu/op_pdist_forward.cpp
@@ -40,10 +40,9 @@ Tensor& _pdist_forward_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  constexpr auto name = "_pdist_forward.out";
 
   ET_SWITCH_FLOATHBF16_TYPES(
-      in_type, ctx, name, CTYPE, [&] { pdist<CTYPE>(in, out, p); });
+      in_type, ctx, "_pdist_forward.out", CTYPE, [&] { pdist<CTYPE>(in, out, p); });
 
   return out;
 }
diff --git a/kernels/portable/cpu/op_prod.cpp b/kernels/portable/cpu/op_prod.cpp
@@ -32,10 +32,9 @@ Tensor& prod_out(
 
   ScalarType in_type = in.scalar_type();
   ScalarType out_type = out.scalar_type();
-  constexpr auto name = "prod.int_out";
 
-  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, name, CTYPE_IN, [&] {
-    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, name, CTYPE_OUT, [&] {
+  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, "prod.int_out", CTYPE_IN, [&] {
+    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, "prod.int_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>(1);
@@ -72,10 +71,9 @@ Tensor& prod_int_out(
 
   ScalarType in_type = in.scalar_type();
   ScalarType out_type = out.scalar_type();
-  constexpr auto name = "prod.int_out";
 
-  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, name, CTYPE_IN, [&] {
-    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, name, CTYPE_OUT, [&] {
+  ET_SWITCH_REALHBBF16_TYPES(in_type, ctx, "prod.int_out", CTYPE_IN, [&] {
+    ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, "prod.int_out", CTYPE_OUT, [&] {
       CTYPE_OUT* out_data = out.mutable_data_ptr<CTYPE_OUT>();
       const bool success = parallel_for_each_reduce_over_dim_output_index(
           in, dim, out, [&](const auto begin, const auto end) {
diff --git a/kernels/portable/cpu/op_reflection_pad1d.cpp b/kernels/portable/cpu/op_reflection_pad1d.cpp
@@ -44,9 +44,8 @@ Tensor& reflection_pad1d_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  constexpr auto name = "reflection_pad1d.out";
 
-  ET_SWITCH_ALL_TYPES(in_type, ctx, name, CTYPE, [&] {
+  ET_SWITCH_ALL_TYPES(in_type, ctx, "reflection_pad1d.out", CTYPE, [&] {
     pad1d<CTYPE>(reflection_ix, in, out, padding);
   });
 
diff --git a/kernels/portable/cpu/op_reflection_pad2d.cpp b/kernels/portable/cpu/op_reflection_pad2d.cpp
@@ -44,9 +44,8 @@ Tensor& reflection_pad2d_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  constexpr auto name = "reflection_pad2d.out";
 
-  ET_SWITCH_ALL_TYPES(in_type, ctx, name, CTYPE, [&] {
+  ET_SWITCH_ALL_TYPES(in_type, ctx, "reflection_pad2d.out", CTYPE, [&] {
     pad2d<CTYPE>(reflection_ix, in, out, padding);
   });
 
diff --git a/kernels/portable/cpu/op_reflection_pad3d.cpp b/kernels/portable/cpu/op_reflection_pad3d.cpp
@@ -44,9 +44,8 @@ Tensor& reflection_pad3d_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  constexpr auto name = "reflection_pad3d.out";
 
-  ET_SWITCH_ALL_TYPES(in_type, ctx, name, CTYPE, [&] {
+  ET_SWITCH_ALL_TYPES(in_type, ctx, "reflection_pad3d.out", CTYPE, [&] {
     pad3d<CTYPE>(reflection_ix, in, out, padding);
   });
 
diff --git a/kernels/portable/cpu/op_repeat_interleave.cpp b/kernels/portable/cpu/op_repeat_interleave.cpp
@@ -72,9 +72,7 @@ Tensor& repeat_interleave_Tensor_out(
 
   int64_t repeats_sum = 0;
 
-  constexpr auto name = "repeat_interleave.Tensor_out";
-
-  ET_SWITCH_TWO_TYPES(Int, Long, repeats.scalar_type(), ctx, name, CTYPE, [&] {
+  ET_SWITCH_TWO_TYPES(Int, Long, repeats.scalar_type(), ctx, "repeat_interleave.Tensor_out", CTYPE, [&] {
     const CTYPE* repeats_data = repeats.const_data_ptr<CTYPE>();
     for (const auto ix : c10::irange(repeats.numel())) {
       repeats_sum += static_cast<int64_t>(repeats_data[ix]);
@@ -106,7 +104,7 @@ Tensor& repeat_interleave_Tensor_out(
       out,
       "Failed to resize output tensor.");
 
-  ET_SWITCH_TWO_TYPES(Int, Long, repeats.scalar_type(), ctx, name, CTYPE, [&] {
+  ET_SWITCH_TWO_TYPES(Int, Long, repeats.scalar_type(), ctx, "repeat_interleave.Tensor_out", CTYPE, [&] {
     const CTYPE* repeats_data = repeats.const_data_ptr<CTYPE>();
     CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
     size_t out_ix = 0;
diff --git a/kernels/portable/cpu/op_replication_pad1d.cpp b/kernels/portable/cpu/op_replication_pad1d.cpp
@@ -36,9 +36,8 @@ Tensor& replication_pad1d_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  constexpr auto name = "replication_pad1d.out";
 
-  ET_SWITCH_ALL_TYPES(in_type, ctx, name, CTYPE, [&] {
+  ET_SWITCH_ALL_TYPES(in_type, ctx, "replication_pad1d.out", CTYPE, [&] {
     pad1d<CTYPE>(replication_ix, in, out, padding);
   });
 
diff --git a/kernels/portable/cpu/op_replication_pad2d.cpp b/kernels/portable/cpu/op_replication_pad2d.cpp
@@ -36,9 +36,8 @@ Tensor& replication_pad2d_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  constexpr auto name = "replication_pad2d.out";
 
-  ET_SWITCH_ALL_TYPES(in_type, ctx, name, CTYPE, [&] {
+  ET_SWITCH_ALL_TYPES(in_type, ctx, "replication_pad2d.out", CTYPE, [&] {
     pad2d<CTYPE>(replication_ix, in, out, padding);
   });
 
diff --git a/kernels/portable/cpu/op_replication_pad3d.cpp b/kernels/portable/cpu/op_replication_pad3d.cpp
@@ -36,9 +36,8 @@ Tensor& replication_pad3d_out(
       out);
 
   ScalarType in_type = in.scalar_type();
-  constexpr auto name = "replication_pad3d.out";
 
-  ET_SWITCH_ALL_TYPES(in_type, ctx, name, CTYPE, [&] {
+  ET_SWITCH_ALL_TYPES(in_type, ctx, "replication_pad3d.out", CTYPE, [&] {
     pad3d<CTYPE>(replication_ix, in, out, padding);
   });
 
diff --git a/kernels/portable/cpu/op_roll.cpp b/kernels/portable/cpu/op_roll.cpp
@@ -80,9 +80,7 @@ Tensor& roll_out(
   size_t dim_shift_array_length = static_cast<size_t>(in.dim()); // NOLINT
   IntArrayRef dim_shifts(dim_shift_array, dim_shift_array_length);
 
-  constexpr auto name = "roll.out";
-
-  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, name, CTYPE, [&] {
+  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, "roll.out", CTYPE, [&] {
     const CTYPE* in_data = in.const_data_ptr<CTYPE>();
     CTYPE* out_data = out.mutable_data_ptr<CTYPE>();
 
diff --git a/kernels/portable/cpu/op_scalar_tensor.cpp b/kernels/portable/cpu/op_scalar_tensor.cpp
@@ -22,9 +22,7 @@ scalar_tensor_out(KernelRuntimeContext& ctx, const Scalar& s, Tensor& out) {
 
   ScalarType out_type = out.scalar_type();
 
-  constexpr auto name = "scalar_tensor.out";
-
-  ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, name, CTYPE, [&]() {
+  ET_SWITCH_REALHBBF16_TYPES(out_type, ctx, "scalar_tensor.out", CTYPE, [&]() {
     auto opt_val_casted = utils::internal::check_overflow_scalar_cast<CTYPE>(s);
     ET_KERNEL_CHECK(ctx, opt_val_casted.has_value(), InvalidArgument, );
     out.mutable_data_ptr<CTYPE>()[0] = opt_val_casted.value();
diff --git a/kernels/portable/cpu/op_scatter.cpp b/kernels/portable/cpu/op_scatter.cpp
@@ -119,9 +119,7 @@ Tensor& scatter_src_out(
   ET_KERNEL_CHECK(
       ctx, resize_tensor(out, in.sizes()) == Error::Ok, InvalidArgument, out);
 
-  constexpr auto name = "scatter.src_out";
-
-  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, name, CTYPE, [&]() {
+  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, "scatter.src_out", CTYPE, [&]() {
     scatter_src_helper<CTYPE>(in, dim, index, src, out);
   });
 
@@ -146,9 +144,7 @@ Tensor& scatter_value_out(
   ET_KERNEL_CHECK(
       ctx, resize_tensor(out, in.sizes()) == Error::Ok, InvalidArgument, out);
 
-  constexpr auto name = "scatter.value_out";
-
-  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, name, CTYPE, [&]() {
+  ET_SWITCH_REALHBBF16_TYPES(in.scalar_type(), ctx, "scatter.value_out", CTYPE, [&]() {
     auto opt_val = utils::internal::check_overflow_scalar_cast<CTYPE>(value);
     ET_KERNEL_CHECK(ctx, opt_val.has_value(), InvalidArgument, );
     auto val = opt_val.value();
diff --git a/kernels/portable/cpu/op_topk.cpp b/kernels/portable/cpu/op_topk.cpp
@@ -196,17 +196,15 @@ std::tuple<Tensor&, Tensor&> topk_values(
       ctx,
       resize_tensor(indices, {target_size, target_dim}) == Error::Ok,
       InvalidArgument,
-      out);
-
-  constexpr auto name = "topk.values";
+        out);
 
   if (in.numel() == 0 || (k == 0 && in.dim() > 0)) {
     return out;
   }
 
   bool temp_mem_allocated = false;
 
-  ET_SWITCH_REALHBF16_TYPES(in.scalar_type(), ctx, name, CTYPE, [&]() {
+  ET_SWITCH_REALHBF16_TYPES(in.scalar_type(), ctx, "topk.values", CTYPE, [&]() {
     using elem_t = std::pair<CTYPE, int64_t>;
     size_t temp_mem_size = nonempty_size(in, dim) * sizeof(elem_t);
 
diff --git a/kernels/portable/cpu/op_var.cpp b/kernels/portable/cpu/op_var.cpp
@@ -91,10 +91,8 @@ Tensor& var_out(
   const size_t num = get_reduced_dim_product(in, dim_list);
   const size_t denom = unbiased ? num - 1 : num;
 
-  constexpr auto name = "var.out";
-
-  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, name, CTYPE_IN, [&] {
-    ET_SWITCH_FLOATHBF16_TYPES(out.scalar_type(), ctx, name, CTYPE_OUT, [&] {
+  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, "var.out", CTYPE_IN, [&] {
+    ET_SWITCH_FLOATHBF16_TYPES(out.scalar_type(), ctx, "var.out", CTYPE_OUT, [&] {
       compute_variance<CTYPE_IN, CTYPE_OUT>(ctx, in, out, dim_list, num, denom);
     });
   });
@@ -123,8 +121,6 @@ Tensor& var_correction_out(
       InvalidArgument,
       out);
 
-  constexpr auto name = "var.correction_out";
-
   double correction_val = 1;
   if (correction.has_value()) {
     correction_val = utils::scalar_to<double>(correction.value());
@@ -133,8 +129,8 @@ Tensor& var_correction_out(
   const size_t num = get_reduced_dim_product(in, dim_list);
   const double denom = num - correction_val;
 
-  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, name, CTYPE_IN, [&] {
-    ET_SWITCH_FLOATHBF16_TYPES(out.scalar_type(), ctx, name, CTYPE_OUT, [&] {
+  ET_SWITCH_FLOATHBF16_TYPES(in.scalar_type(), ctx, "var.correction_out", CTYPE_IN, [&] {
+    ET_SWITCH_FLOATHBF16_TYPES(out.scalar_type(), ctx, "var.correction_out", CTYPE_OUT, [&] {
       compute_variance<CTYPE_IN, CTYPE_OUT>(ctx, in, out, dim_list, num, denom);
     });
   });

Original file line number	Diff line number	Diff line change
`@@ -40,10 +40,9 @@ Tensor& _pdist_forward_out(`
`40`	`40`	`out);`
`41`	`41`
`42`	`42`	`ScalarType in_type = in.scalar_type();`
`43`		`- constexpr auto name = "_pdist_forward.out";`
`44`	`43`
`45`	`44`	`ET_SWITCH_FLOATHBF16_TYPES(`
`46`		`- in_type, ctx, name, CTYPE, [&] { pdist<CTYPE>(in, out, p); });`
	`45`	`+ in_type, ctx, "_pdist_forward.out", CTYPE, [&] { pdist<CTYPE>(in, out, p); });`
`47`	`46`
`48`	`47`	`return out;`
`49`	`48`	`}`