Reapply "Implement unary_ufunc functions using elementwise_util (#9386)"

swolchok · swolchok · commit 15518c6e1996 · 2025-06-25T08:35:49.000-07:00
Pull Request resolved: #11943 This PR was reverted due to internal test failures, which should be fixed now (and is being sent as an exported diff to make sure). Original summary: One less set of independent implementations to worry about going forward (e.g., we don't have to vectorize these separately from elementwise_util and they get all benefits of elementwise_util). ghstack-source-id: 292614913 @exported-using-ghexport Differential Revision: [D76754824](https://our.internmc.facebook.com/intern/diff/D76754824/)
diff --git a/backends/cadence/fusion_g3/operators/op_exp.cpp b/backends/cadence/fusion_g3/operators/op_exp.cpp
@@ -59,8 +59,10 @@ Tensor& exp_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 
     return out;
   } else {
+    static constexpr const char op_name[] = "exp.out";
     return torch::executor::native::internal::
-        unary_ufunc_realhbbf16_to_floathbf16(std::exp, ctx, in, out);
+        unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+            [](auto x) { return executorch::math::exp(x); }, ctx, in, out);
   }
 }
 
diff --git a/backends/cadence/fusion_g3/operators/op_rsqrt.cpp b/backends/cadence/fusion_g3/operators/op_rsqrt.cpp
@@ -25,14 +25,6 @@ namespace impl {
 namespace G3 {
 namespace native {
 
-namespace {
-
-double rsqrt(double x) {
-  return 1.0 / std::sqrt(x);
-}
-
-} // namespace
-
 Tensor& rsqrt_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 #ifdef OP_ARG_CHECK
   // Resize for dynamic shape
@@ -60,12 +52,14 @@ Tensor& rsqrt_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 
     return out;
   } else {
+    static constexpr const char op_name[] = "rsqrt.out";
     return torch::executor::native::internal::
-        unary_ufunc_realhbbf16_to_floathbf16(rsqrt, ctx, in, out);
+        unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+            [](auto x) { return executorch::math::rsqrt(x); }, ctx, in, out);
   }
 }
 
 } // namespace native
 } // namespace G3
 } // namespace impl
-} // namespace cadence
+} // namespace cadence
diff --git a/backends/cadence/fusion_g3/operators/op_sqrt.cpp b/backends/cadence/fusion_g3/operators/op_sqrt.cpp
@@ -54,8 +54,10 @@ Tensor& sqrt_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 
     return out;
   } else {
+    static constexpr const char op_name[] = "sqrt.out";
     return torch::executor::native::internal::
-        unary_ufunc_realhbbf16_to_floathbf16(std::sqrt, ctx, in, out);
+        unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+            [](auto x) { return executorch::math::sqrt(x); }, ctx, in, out);
   }
 }
 
diff --git a/backends/cadence/fusion_g3/operators/op_tanh.cpp b/backends/cadence/fusion_g3/operators/op_tanh.cpp
@@ -54,8 +54,10 @@ Tensor& tanh_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 
     return out;
   } else {
+    static constexpr const char op_name[] = "tanh.out";
     return torch::executor::native::internal::
-        unary_ufunc_realhbbf16_to_floathbf16(std::tanh, ctx, in, out);
+        unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+            [](auto x) { return executorch::math::tanh(x); }, ctx, in, out);
   }
 }
 
diff --git a/backends/cadence/hifi/operators/op_rsqrt.cpp b/backends/cadence/hifi/operators/op_rsqrt.cpp
@@ -19,13 +19,6 @@ namespace cadence {
 namespace impl {
 namespace HiFi {
 namespace native {
-namespace {
-
-double rsqrt(double x) {
-  return 1.0 / std::sqrt(x);
-}
-
-} // namespace
 
 Tensor& rsqrt_out(RuntimeContext& ctx, const Tensor& in, Tensor& out) {
   bool optimized = true;
@@ -45,8 +38,10 @@ Tensor& rsqrt_out(RuntimeContext& ctx, const Tensor& in, Tensor& out) {
     return out;
   }
 
+  static constexpr const char op_name[] = "rsqrt.out";
   return torch::executor::native::internal::
-      unary_ufunc_realhbbf16_to_floathbf16(rsqrt, ctx, in, out);
+      unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+          [](auto x) { return executorch::math::rsqrt(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/backends/cadence/hifi/operators/op_tanh.cpp b/backends/cadence/hifi/operators/op_tanh.cpp
@@ -34,11 +34,13 @@ Tensor& tanh_out(RuntimeContext& ctx, const Tensor& in, Tensor& out) {
     return out;
   }
 
+  static constexpr const char op_name[] = "tanh.out";
   return torch::executor::native::internal::
-      unary_ufunc_realhbbf16_to_floathbf16(std::tanh, ctx, in, out);
+      unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+          [](auto x) { return executorch::math::tanh(x); }, ctx, in, out);
 }
 
 } // namespace native
 } // namespace HiFi
 } // namespace impl
-} // namespace cadence
+} // namespace cadence
diff --git a/kernels/portable/cpu/op_acos.cpp b/kernels/portable/cpu/op_acos.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& acos_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::acos, ctx, in, out);
+  static constexpr const char op_name[] = "acos.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::acos(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_acosh.cpp b/kernels/portable/cpu/op_acosh.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& acosh_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::acosh, ctx, in, out);
+  static constexpr const char op_name[] = "acosh.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::acosh(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_asin.cpp b/kernels/portable/cpu/op_asin.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& asin_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::asin, ctx, in, out);
+  static constexpr const char op_name[] = "asin.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::asin(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_asinh.cpp b/kernels/portable/cpu/op_asinh.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& asinh_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::asinh, ctx, in, out);
+  static constexpr const char op_name[] = "asinh.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::asinh(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_atan.cpp b/kernels/portable/cpu/op_atan.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& atan_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::atan, ctx, in, out);
+  static constexpr const char op_name[] = "atan.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::atan(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_atanh.cpp b/kernels/portable/cpu/op_atanh.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& atanh_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::atanh, ctx, in, out);
+  static constexpr const char op_name[] = "atanh.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::atanh(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_ceil.cpp b/kernels/portable/cpu/op_ceil.cpp
@@ -17,7 +17,9 @@ namespace native {
 using executorch::aten::Tensor;
 
 Tensor& ceil_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbf16(std::ceil, ctx, in, out);
+  static constexpr const char op_name[] = "ceil.out";
+  return internal::unary_ufunc_realhbf16<op_name>(
+      [](auto x) { return executorch::math::ceil(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_cos.cpp b/kernels/portable/cpu/op_cos.cpp
@@ -15,7 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& cos_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(std::cos, ctx, in, out);
+  static constexpr const char op_name[] = "cos.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::cos(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_cosh.cpp b/kernels/portable/cpu/op_cosh.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& cosh_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::cosh, ctx, in, out);
+  static constexpr const char op_name[] = "cosh.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::cosh(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_erf.cpp b/kernels/portable/cpu/op_erf.cpp
@@ -15,7 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& erf_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(std::erf, ctx, in, out);
+  static constexpr const char op_name[] = "erf.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::erf(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_exp.cpp b/kernels/portable/cpu/op_exp.cpp
@@ -15,7 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& exp_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(std::exp, ctx, in, out);
+  static constexpr const char op_name[] = "exp.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::exp(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_expm1.cpp b/kernels/portable/cpu/op_expm1.cpp
@@ -7,16 +7,19 @@
  */
 
 #include <executorch/kernels/portable/cpu/pattern/pattern.h>
+#include <executorch/kernels/portable/cpu/util/elementwise_util.h>
 #include <executorch/runtime/kernel/kernel_includes.h>
 #include <cmath>
+#include <type_traits>
 
 namespace torch {
 namespace executor {
 namespace native {
 
 Tensor& expm1_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::expm1, ctx, in, out);
+  static constexpr const char op_name[] = "expm1.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::expm1(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_floor.cpp b/kernels/portable/cpu/op_floor.cpp
@@ -17,7 +17,9 @@ namespace native {
 using executorch::aten::Tensor;
 
 Tensor& floor_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbf16(std::floor, ctx, in, out);
+  static constexpr const char op_name[] = "floor.out";
+  return internal::unary_ufunc_realhbf16<op_name>(
+      [](auto x) { return executorch::math::floor(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_isinf.cpp b/kernels/portable/cpu/op_isinf.cpp
@@ -17,8 +17,9 @@ namespace native {
 Tensor& isinf_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
   // Lambda is syntactic sugar needed to workaround compilation on some older
   // non-compatible distros where isnan is returning int rather than bool
-  return internal::unary_ufunc_realhb_to_bool(
-      [](double x) -> bool { return std::isinf(x); }, ctx, in, out);
+  static constexpr const char op_name[] = "isinf.out";
+  return internal::unary_ufunc_realhb_to_bool<op_name>(
+      [](auto x) -> bool { return std::isinf(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_isnan.cpp b/kernels/portable/cpu/op_isnan.cpp
@@ -17,8 +17,9 @@ namespace native {
 Tensor& isnan_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
   // Lambda is syntactic sugar needed to workaround compilation on some older
   // non-compatible distros where isnan is returning int rather than bool
-  return internal::unary_ufunc_realhb_to_bool(
-      [](double x) -> bool { return std::isnan(x); }, ctx, in, out);
+  static constexpr const char op_name[] = "isnan.out";
+  return internal::unary_ufunc_realhb_to_bool<op_name>(
+      [](auto x) -> bool { return std::isnan(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_log.cpp b/kernels/portable/cpu/op_log.cpp
@@ -15,7 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& log_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(std::log, ctx, in, out);
+  static constexpr const char op_name[] = "log.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::log(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_log10.cpp b/kernels/portable/cpu/op_log10.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& log10_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::log10, ctx, in, out);
+  static constexpr const char op_name[] = "log10.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::log10(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_log1p.cpp b/kernels/portable/cpu/op_log1p.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& log1p_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::log1p, ctx, in, out);
+  static constexpr const char op_name[] = "log1p.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::log1p(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_log2.cpp b/kernels/portable/cpu/op_log2.cpp
@@ -15,8 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& log2_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      std::log2, ctx, in, out);
+  static constexpr const char op_name[] = "log2.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::log2(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_reciprocal.cpp b/kernels/portable/cpu/op_reciprocal.cpp
@@ -12,18 +12,11 @@
 namespace torch {
 namespace executor {
 namespace native {
-namespace {
-
-double reciprocal(double x) {
-  return 1.0 / x;
-}
-
-} // namespace
-
 Tensor&
 reciprocal_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(
-      reciprocal, ctx, in, out);
+  static constexpr const char op_name[] = "reciprocal.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::reciprocal(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_rsqrt.cpp b/kernels/portable/cpu/op_rsqrt.cpp
@@ -12,16 +12,11 @@
 namespace torch {
 namespace executor {
 namespace native {
-namespace {
-
-double rsqrt(double x) {
-  return 1.0 / std::sqrt(x);
-}
-
-} // namespace
 
 Tensor& rsqrt_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(rsqrt, ctx, in, out);
+  static constexpr const char op_name[] = "rsqrt.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::rsqrt(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_sin.cpp b/kernels/portable/cpu/op_sin.cpp
@@ -15,7 +15,9 @@ namespace executor {
 namespace native {
 
 Tensor& sin_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
-  return internal::unary_ufunc_realhbbf16_to_floathbf16(std::sin, ctx, in, out);
+  static constexpr const char op_name[] = "sin.out";
+  return internal::unary_ufunc_realhbbf16_to_floathbf16<op_name>(
+      [](auto x) { return executorch::math::sin(x); }, ctx, in, out);
 }
 
 } // namespace native
diff --git a/kernels/portable/cpu/op_sinh.cpp b/kernels/portable/cpu/op_sinh.cpp
diff --git a/kernels/portable/cpu/op_sqrt.cpp b/kernels/portable/cpu/op_sqrt.cpp
diff --git a/kernels/portable/cpu/op_tan.cpp b/kernels/portable/cpu/op_tan.cpp
diff --git a/kernels/portable/cpu/op_tanh.cpp b/kernels/portable/cpu/op_tanh.cpp
diff --git a/kernels/portable/cpu/op_trunc.cpp b/kernels/portable/cpu/op_trunc.cpp
diff --git a/kernels/portable/cpu/pattern/pattern.cpp b/kernels/portable/cpu/pattern/pattern.cpp
diff --git a/kernels/portable/cpu/pattern/pattern.h b/kernels/portable/cpu/pattern/pattern.h
diff --git a/kernels/portable/cpu/pattern/targets.bzl b/kernels/portable/cpu/pattern/targets.bzl
diff --git a/kernels/portable/cpu/pattern/unary_ufunc_realhb_to_bool.cpp b/kernels/portable/cpu/pattern/unary_ufunc_realhb_to_bool.cpp
diff --git a/kernels/portable/cpu/pattern/unary_ufunc_realhbbf16_to_floathbf16.cpp b/kernels/portable/cpu/pattern/unary_ufunc_realhbbf16_to_floathbf16.cpp
diff --git a/kernels/portable/cpu/pattern/unary_ufunc_realhbf16.cpp b/kernels/portable/cpu/pattern/unary_ufunc_realhbf16.cpp
diff --git a/kernels/portable/cpu/util/vectorized_math.h b/kernels/portable/cpu/util/vectorized_math.h
diff --git a/shim_et/xplat/executorch/kernels/portable/op_registration_util.bzl b/shim_et/xplat/executorch/kernels/portable/op_registration_util.bzl

Original file line number	Diff line number	Diff line change
`@@ -59,8 +59,10 @@ Tensor& exp_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {`
`59`	`59`
`60`	`60`	`return out;`
`61`	`61`	`} else {`
	`62`	`+ static constexpr const char op_name[] = "exp.out";`
`62`	`63`	`return torch::executor::native::internal::`
`63`		`- unary_ufunc_realhbbf16_to_floathbf16(std::exp, ctx, in, out);`
	`64`	`+ unary_ufunc_realhbbf16_to_floathbf16<op_name>(`
	`65`	`+ [](auto x) { return executorch::math::exp(x); }, ctx, in, out);`
`64`	`66`	`}`
`65`	`67`	`}`
`66`	`68`
Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,10 @@ Tensor& sqrt_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {`
`54`	`54`
`55`	`55`	`return out;`
`56`	`56`	`} else {`
	`57`	`+ static constexpr const char op_name[] = "sqrt.out";`
`57`	`58`	`return torch::executor::native::internal::`
`58`		`- unary_ufunc_realhbbf16_to_floathbf16(std::sqrt, ctx, in, out);`
	`59`	`+ unary_ufunc_realhbbf16_to_floathbf16<op_name>(`
	`60`	`+ [](auto x) { return executorch::math::sqrt(x); }, ctx, in, out);`
`59`	`61`	`}`
`60`	`62`	`}`
`61`	`63`
Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,10 @@ Tensor& tanh_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {`
`54`	`54`
`55`	`55`	`return out;`
`56`	`56`	`} else {`
	`57`	`+ static constexpr const char op_name[] = "tanh.out";`
`57`	`58`	`return torch::executor::native::internal::`
`58`		`- unary_ufunc_realhbbf16_to_floathbf16(std::tanh, ctx, in, out);`
	`59`	`+ unary_ufunc_realhbbf16_to_floathbf16<op_name>(`
	`60`	`+ [](auto x) { return executorch::math::tanh(x); }, ctx, in, out);`
`59`	`61`	`}`
`60`	`62`	`}`
`61`	`63`
Original file line number	Diff line number	Diff line change
`@@ -34,11 +34,13 @@ Tensor& tanh_out(RuntimeContext& ctx, const Tensor& in, Tensor& out) {`
`34`	`34`	`return out;`
`35`	`35`	`}`
`36`	`36`
	`37`	`+ static constexpr const char op_name[] = "tanh.out";`
`37`	`38`	`return torch::executor::native::internal::`
`38`		`- unary_ufunc_realhbbf16_to_floathbf16(std::tanh, ctx, in, out);`
	`39`	`+ unary_ufunc_realhbbf16_to_floathbf16<op_name>(`
	`40`	`+ [](auto x) { return executorch::math::tanh(x); }, ctx, in, out);`
`39`	`41`	`}`
`40`	`42`
`41`	`43`	`} // namespace native`
`42`	`44`	`} // namespace HiFi`
`43`	`45`	`} // namespace impl`
`44`		`-} // namespace cadence`
	`46`	`+} // namespace cadence`