Use std::optinal

Author: cyyever

backends/cadence/hifi/operators/op_mean.cpp

@@ -18,7 +18,7 @@ using executorch::aten::ScalarType;
 using executorch::aten::Tensor;
 using executorch::runtime::ArrayRef;
 using torch::executor::Error;
-using torch::executor::optional;
+using std::optional;
 
 namespace cadence {
 namespace impl {

codegen/api/types/types.py

@@ -59,7 +59,7 @@ class OptionalCType(CType):
 
     def cpp_type(self, *, strip_ref: bool = False) -> str:
         # Do not pass `strip_ref` recursively.
-        return f"torch::executor::optional<{self.elem.cpp_type()}>"
+        return f"std::optional<{self.elem.cpp_type()}>"
 
     def remove_const_ref(self) -> CType:
         return OptionalCType(self.elem.remove_const_ref())

extension/aten_util/make_aten_functor_from_et_functor.h

@@ -67,12 +67,12 @@ struct type_map<torch::executor::Tensor> final {
 
 // Optional.
 template <class T>
-struct type_map<torch::executor::optional<T>> final {
+struct type_map<std::optional<T>> final {
   using type = std::optional<typename type_map<T>::type>;
 };
 
 template <class T>
-struct type_map<torch::executor::optional<T>&> final {
+struct type_map<std::optional<T>&> final {
   using type = std::optional<typename type_map<T>::type>&;
 };
 
@@ -166,7 +166,7 @@ struct type_convert<
                 typename remove_const_ref<AOptional>::type::value_type>> &&
         std::is_same_v<
             typename remove_const_ref<EOptional>::type,
-            torch::executor::optional<
+            std::optional<
                 typename remove_const_ref<EOptional>::type::value_type>>>>
     final {
  public:

extension/aten_util/test/make_aten_functor_from_et_functor_test.cpp

@@ -32,8 +32,8 @@ Tensor& add_1_out(const Tensor& a, Tensor& out) {
 }
 
 Tensor& add_optional_scalar_out(
-    torch::executor::optional<int64_t> s1,
-    torch::executor::optional<int64_t> s2,
+    std::optional<int64_t> s1,
+    std::optional<int64_t> s2,
     Tensor& out) {
   if (s1.has_value()) {
     out.mutable_data_ptr<int64_t>()[0] += s1.value();
@@ -45,8 +45,8 @@ Tensor& add_optional_scalar_out(
 }
 
 Tensor& add_optional_tensor_out(
-    torch::executor::optional<torch::executor::Tensor> s1,
-    torch::executor::optional<torch::executor::Tensor> s2,
+    std::optional<torch::executor::Tensor> s1,
+    std::optional<torch::executor::Tensor> s2,
     Tensor& out) {
   if (s1.has_value()) {
     out.mutable_data_ptr<int64_t>()[0] +=
@@ -79,7 +79,7 @@ Tensor& sum_arrayref_tensor_out(
 
 Tensor& sum_arrayref_optional_tensor_out(
     torch::executor::ArrayRef<
-        torch::executor::optional<torch::executor::Tensor>> a,
+        std::optional<torch::executor::Tensor>> a,
     Tensor& out) {
   for (int i = 0; i < a.size(); i++) {
     if (a[i].has_value()) {
@@ -137,20 +137,20 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestTypeMap_Tensor) {
 TEST_F(MakeATenFunctorFromETFunctorTest, TestTypeMap_Optionals) {
   // Scalar.
   EXPECT_TRUE((std::is_same<
-               type_map<torch::executor::optional<int64_t>>::type,
+               type_map<std::optional<int64_t>>::type,
                std::optional<int64_t>>::value));
   // Tensor.
   EXPECT_TRUE(
       (std::is_same<
-          type_map<torch::executor::optional<torch::executor::Tensor>>::type,
+          type_map<std::optional<torch::executor::Tensor>>::type,
           std::optional<at::Tensor>>::value));
   // ArrayRef.
   EXPECT_TRUE((std::is_same<
-               type_map<torch::executor::optional<
+               type_map<std::optional<
                    torch::executor::ArrayRef<int64_t>>>::type,
                std::optional<c10::ArrayRef<int64_t>>>::value));
   EXPECT_TRUE((std::is_same<
-               type_map<torch::executor::optional<
+               type_map<std::optional<
                    torch::executor::ArrayRef<torch::executor::Tensor>>>::type,
                std::optional<c10::ArrayRef<at::Tensor>>>::value));
 }
@@ -168,11 +168,11 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestTypeMap_ArrayRef) {
   // Optionals.
   EXPECT_TRUE((std::is_same<
                type_map<torch::executor::ArrayRef<
-                   torch::executor::optional<int64_t>>>::type,
+                   std::optional<int64_t>>>::type,
                c10::ArrayRef<std::optional<int64_t>>>::value));
   EXPECT_TRUE((std::is_same<
                type_map<torch::executor::ArrayRef<
-                   torch::executor::optional<torch::executor::Tensor>>>::type,
+                   std::optional<torch::executor::Tensor>>>::type,
                c10::ArrayRef<std::optional<at::Tensor>>>::value));
 }
 
@@ -193,17 +193,17 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_OptionalScalar) {
   // Convert optional at to et.
   auto optional_at_in = std::optional<int64_t>();
   auto optional_et =
-      type_convert<std::optional<int64_t>, torch::executor::optional<int64_t>>(
+      type_convert<std::optional<int64_t>, std::optional<int64_t>>(
           optional_at_in)
           .call();
   EXPECT_TRUE(
-      (std::is_same<decltype(optional_et), torch::executor::optional<int64_t>>::
+      (std::is_same<decltype(optional_et), std::optional<int64_t>>::
            value));
 
   // Convert optional et to at.
-  auto optional_et_in = torch::executor::optional<int64_t>();
+  auto optional_et_in = std::optional<int64_t>();
   auto optional_at_out =
-      type_convert<torch::executor::optional<int64_t>, std::optional<int64_t>>(
+      type_convert<std::optional<int64_t>, std::optional<int64_t>>(
           optional_et_in)
           .call();
   EXPECT_TRUE(
@@ -216,17 +216,17 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_OptionalTensor) {
   auto optional_et =
       type_convert<
           std::optional<at::Tensor>,
-          torch::executor::optional<torch::executor::Tensor>>(optional_at_in)
+          std::optional<torch::executor::Tensor>>(optional_at_in)
           .call();
   EXPECT_TRUE((std::is_same<
                decltype(optional_et),
-               torch::executor::optional<torch::executor::Tensor>>::value));
+               std::optional<torch::executor::Tensor>>::value));
 
   // Convert optional et to at.
   torch::executor::testing::TensorFactory<ScalarType::Int> tf;
-  auto et_in = torch::executor::optional<torch::executor::Tensor>(tf.ones({3}));
+  auto et_in = std::optional<torch::executor::Tensor>(tf.ones({3}));
   auto optional_at_out = type_convert<
-                             torch::executor::optional<torch::executor::Tensor>,
+                             std::optional<torch::executor::Tensor>,
                              std::optional<at::Tensor>>(optional_et)
                              .call();
   EXPECT_TRUE(
@@ -429,15 +429,15 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_ConstRefOptionals) {
   auto const_optional_et =
       type_convert<
           const std::optional<int64_t>,
-          torch::executor::optional<int64_t>>(const_optional_at_in)
+          std::optional<int64_t>>(const_optional_at_in)
           .call();
   EXPECT_TRUE(const_optional_et.has_value());
   EXPECT_EQ(const_optional_et.value(), 42);
 
   // Test optional scalar reference conversion
   std::optional<int64_t> optional_at_ref_in = std::optional<int64_t>(24);
   auto optional_et_from_ref =
-      type_convert<std::optional<int64_t>&, torch::executor::optional<int64_t>>(
+      type_convert<std::optional<int64_t>&, std::optional<int64_t>>(
           optional_at_ref_in)
           .call();
   EXPECT_TRUE(optional_et_from_ref.has_value());
@@ -449,7 +449,7 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_ConstRefOptionals) {
   auto const_optional_et_from_ref =
       type_convert<
           const std::optional<int64_t>&,
-          torch::executor::optional<int64_t>>(const_optional_at_ref_in)
+          std::optional<int64_t>>(const_optional_at_ref_in)
           .call();
   EXPECT_TRUE(const_optional_et_from_ref.has_value());
   EXPECT_EQ(const_optional_et_from_ref.value(), 84);
@@ -459,7 +459,7 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_ConstRefOptionals) {
       std::optional<at::Tensor>(torch::tensor({5}));
   auto const_optional_tensor_converter = type_convert<
       const std::optional<at::Tensor>,
-      torch::executor::optional<torch::executor::Tensor>>(
+      std::optional<torch::executor::Tensor>>(
       const_optional_tensor_at_in);
   auto const_optional_tensor_et = const_optional_tensor_converter.call();
   EXPECT_TRUE(const_optional_tensor_et.has_value());
@@ -470,7 +470,7 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_ConstRefOptionals) {
       std::optional<at::Tensor>(torch::tensor({7}));
   auto optional_tensor_converter_from_ref = type_convert<
       std::optional<at::Tensor>&,
-      torch::executor::optional<torch::executor::Tensor>>(
+      std::optional<torch::executor::Tensor>>(
       optional_tensor_at_ref_in);
   auto optional_tensor_et_from_ref = optional_tensor_converter_from_ref.call();
   EXPECT_TRUE(optional_tensor_et_from_ref.has_value());
@@ -482,7 +482,7 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_ConstRefOptionals) {
       std::optional<at::Tensor>(torch::tensor({9}));
   auto const_optional_tensor_converter_from_ref = type_convert<
       const std::optional<at::Tensor>&,
-      torch::executor::optional<torch::executor::Tensor>>(
+      std::optional<torch::executor::Tensor>>(
       const_optional_tensor_at_ref_in);
   auto const_optional_tensor_et_from_ref =
       const_optional_tensor_converter_from_ref.call();
@@ -496,7 +496,7 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_ConstRefOptionals) {
   auto empty_const_optional_et =
       type_convert<
           const std::optional<int64_t>,
-          torch::executor::optional<int64_t>>(empty_const_optional_at_in)
+          std::optional<int64_t>>(empty_const_optional_at_in)
           .call();
   EXPECT_FALSE(empty_const_optional_et.has_value());
 
@@ -505,7 +505,7 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_ConstRefOptionals) {
   auto empty_const_optional_tensor_et =
       type_convert<
           const std::optional<at::Tensor>,
-          torch::executor::optional<torch::executor::Tensor>>(
+          std::optional<torch::executor::Tensor>>(
           empty_const_optional_tensor_at_in)
           .call();
   EXPECT_FALSE(empty_const_optional_tensor_et.has_value());

kernels/optimized/cpu/op_linear.cpp

@@ -74,7 +74,7 @@ Tensor& opt_linear_out(
     RuntimeContext& ctx,
     const Tensor& in,
     const Tensor& mat2,
-    const optional<Tensor>& bias,
+    const std::optional<Tensor>& bias,
     Tensor& out) {
   ET_KERNEL_CHECK(ctx, check_linear_args(in, mat2, out), InvalidArgument, out);
 

kernels/optimized/cpu/op_native_layer_norm.cpp

@@ -27,8 +27,8 @@ template <typename CTYPE>
 void layer_norm(
     const Tensor& input,
     IntArrayRef normalized_shape,
-    const optional<Tensor>& weight,
-    const optional<Tensor>& bias,
+    const std::optional<Tensor>& weight,
+    const std::optional<Tensor>& bias,
     CTYPE eps,
     Tensor& out,
     Tensor& mean,

kernels/portable/cpu/op_any.cpp

@@ -54,7 +54,7 @@ Tensor& any_all_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
 Tensor& any_dims_out(
     KernelRuntimeContext& ctx,
     const Tensor& in,
-    optional<ArrayRef<int64_t>> dim_list,
+    std::optional<ArrayRef<int64_t>> dim_list,
     bool keepdim,
     Tensor& out) {
   (void)ctx;

kernels/portable/cpu/op_argmax.cpp

@@ -25,7 +25,7 @@ using std::optional;
 Tensor& argmax_out(
     KernelRuntimeContext& ctx,
     const Tensor& in,
-    optional<int64_t> dim,
+    std::optional<int64_t> dim,
     bool keepdim,
     Tensor& out) {
   (void)ctx;

kernels/portable/cpu/op_argmin.cpp

@@ -25,7 +25,7 @@ using std::optional;
 Tensor& argmin_out(
     KernelRuntimeContext& ctx,
     const Tensor& in,
-    optional<int64_t> dim,
+    std::optional<int64_t> dim,
     bool keepdim,
     Tensor& out) {
   (void)ctx;

kernels/portable/cpu/op_as_strided_copy.cpp

@@ -21,7 +21,7 @@ Tensor& as_strided_copy_out(
     const Tensor& in,
     ArrayRef<int64_t> size,
     ArrayRef<int64_t> stride,
-    optional<int64_t> storage_offset,
+    std::optional<int64_t> storage_offset,
     Tensor& out) {
   (void)ctx;