react-native-executorch 0.5.6 → 0.5.8

package/third-party/include/executorch/runtime/backend/options.h

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <array>
+#include <cstddef>
+#include <cstring>
+#include <executorch/runtime/core/error.h>
+#include <executorch/runtime/core/span.h>
+#include <variant>
+
+namespace executorch {
+namespace runtime {
+
+static constexpr size_t kMaxOptionKeyLength = 64;
+static constexpr size_t kMaxOptionValueLength = 256;
+
+// All string keys and values must have static storage duration (string
+// literals, static const char arrays, or global constants). The BackendOptions
+// class does NOT take ownership of strings.
+using OptionValue =
+    std::variant<bool, int, std::array<char, kMaxOptionValueLength>>;
+
+struct BackendOption {
+  // key is the name of the backend option, like num_threads, enable_profiling,
+  // etc
+  char key[kMaxOptionKeyLength]{};
+  // value is the value of the backend option, like 4, true, etc
+  OptionValue value;
+};
+
+/**
+ * A template class for storing and managing backend-specific configuration
+ * options.
+ *
+ * This class provides a type-safe way to store key-value pairs for backend
+ * configuration, with compile-time capacity limits and runtime type checking.
+ * It supports bool, int, and const char* value types.
+ *
+ * @tparam MaxCapacity The maximum number of options that can be stored
+ */
+template <size_t MaxCapacity> class BackendOptions {
+public:
+  /**
+   * Copy constructor
+   */
+  BackendOptions(const BackendOptions &other) : size_(other.size_) {
+    for (size_t i = 0; i < size_; ++i) {
+      options_[i] = other.options_[i];
+    }
+  }
+
+  /**
+   * Copy assignment operator
+   */
+  BackendOptions &operator=(const BackendOptions &other) {
+    if (this != &other) {
+      size_ = other.size_;
+      for (size_t i = 0; i < size_; ++i) {
+        options_[i] = other.options_[i];
+      }
+    }
+    return *this;
+  }
+
+  /**
+   * Default constructor - initializes with zero options.
+   */
+  BackendOptions() : size_(0) {}
+
+  /**
+   * Returns a mutable view of all stored options as a Span.
+   *
+   * @return A mutable Span containing all BackendOption entries
+   */
+  executorch::runtime::Span<BackendOption> view() {
+    return executorch::runtime::Span<BackendOption>(options_, size_);
+  }
+
+  /**
+   * Sets a boolean option value for the given key.
+   * If the key already exists, updates its value. Otherwise, adds a new option.
+   *
+   * @tparam N The length of the key string (automatically deduced)
+   * @param key The option key (must be a string literal or array)
+   * @param value The boolean value to set
+   * @return Error::Ok on success, Error::InvalidArgument if storage is full
+   */
+  template <size_t N>
+  Error set_option(const char (&key)[N], bool value) noexcept {
+    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
+    return set_option_impl(key, value);
+  }
+
+  /**
+   * Sets an integer option value for the given key.
+   * If the key already exists, updates its value. Otherwise, adds a new option.
+   *
+   * @tparam N The length of the key string (automatically deduced)
+   * @param key The option key (must be a string literal or array)
+   * @param value The integer value to set
+   * @return Error::Ok on success, Error::InvalidArgument if storage is full
+   */
+  template <size_t N>
+  Error set_option(const char (&key)[N], int value) noexcept {
+    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
+    return set_option_impl(key, value);
+  }
+
+  /**
+   * Sets a string option value for the given key.
+   * If the key already exists, updates its value. Otherwise, adds a new option.
+   *
+   * Note: The string value must have static storage duration. This class does
+   * NOT take ownership of the string - it only stores the pointer.
+   *
+   * @tparam N The length of the key string (automatically deduced)
+   * @param key The option key (must be a string literal or array)
+   * @param value The string value to set (must have static storage duration)
+   * @return Error::Ok on success, Error::InvalidArgument if storage is full
+   */
+  template <size_t N>
+  Error set_option(const char (&key)[N], const char *value) noexcept {
+    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
+    // Create a fixed-size array and copy the string
+    std::array<char, kMaxOptionValueLength> arr{};
+    strncpy(arr.data(), value, kMaxOptionValueLength - 1);
+    arr[kMaxOptionValueLength - 1] = '\0'; // Ensure null termination
+    return set_option_impl(key, arr);
+  }
+  /**
+   * Retrieves an option value by key and type.
+   *
+   * @tparam T The expected type of the option value (bool, int, or const char*)
+   * @tparam KeyLen The length of the key string (automatically deduced)
+   * @param key The option key to look up
+   * @param out Reference to store the retrieved value
+   * @return Error::Ok if found and type matches, Error::NotFound if key doesn't
+   * exist, Error::InvalidArgument if type doesn't match
+   */
+  template <typename T, size_t KeyLen>
+  Error get_option(const char (&key)[KeyLen], T &out) const {
+    static_assert(KeyLen <= kMaxOptionKeyLength, "Option key is too long");
+    for (size_t i = 0; i < size_; ++i) {
+      if (std::strcmp(options_[i].key, key) == 0) {
+        // Special handling for string (convert array to const char*)
+        if constexpr (std::is_same_v<T, const char *>) {
+          if (auto *arr = std::get_if<std::array<char, kMaxOptionValueLength>>(
+                  &options_[i].value)) {
+            out = arr->data(); // Return pointer to stored array
+            return Error::Ok;
+          }
+        }
+        // Default handling for bool/int
+        else if (auto *val = std::get_if<T>(&options_[i].value)) {
+          out = *val;
+          return Error::Ok;
+        }
+        return Error::InvalidArgument;
+      }
+    }
+    return Error::NotFound;
+  }
+
+private:
+  BackendOption options_[MaxCapacity]{}; // Storage for backend options
+  size_t size_;                          // Current number of options
+
+  /**
+   * Internal implementation for setting option values.
+   * Handles both updating existing options and adding new ones.
+   *
+   * @tparam T The type of the value (bool, int, or const char*)
+   * @param key The option key
+   * @param value The value to set
+   * @return Error::Ok on success, Error::InvalidArgument if storage is full
+   */
+  template <typename T> Error set_option_impl(const char *key, T value) {
+    // Update existing if found
+    for (size_t i = 0; i < size_; ++i) {
+      if (strcmp(options_[i].key, key) == 0) {
+        options_[i].value = value;
+        return Error::Ok;
+      }
+    }
+    if (size_ < MaxCapacity) {
+      BackendOption new_option;
+      const size_t key_len = std::strlen(key);
+      const size_t copy_len = std::min(key_len, kMaxOptionKeyLength - 1);
+      std::memcpy(new_option.key, key, copy_len);
+      new_option.key[copy_len] = '\0';
+      new_option.value = value;       // Restored value assignment
+      options_[size_++] = new_option; // Store option and increment size
+      return Error::Ok;
+    }
+    return Error::InvalidArgument;
+  }
+};
+
+} // namespace runtime
+} // namespace executorch

package/third-party/include/executorch/runtime/core/evalue.h

@@ -73,9 +73,8 @@ private:
 };
 
 template <>
-executorch::aten::ArrayRef<executorch::aten::optional<executorch::aten::Tensor>>
-BoxedEvalueList<executorch::aten::optional<executorch::aten::Tensor>>::get()
-    const;
+executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>
+BoxedEvalueList<std::optional<executorch::aten::Tensor>>::get() const;
 
 // Aggregate typing system similar to IValue only slimmed down with less
 // functionality, no dependencies on atomic, and fewer supported types to better
@@ -98,7 +97,7 @@ struct EValue {
       executorch::aten::ArrayRef<bool> as_bool_list;
       BoxedEvalueList<int64_t> as_int_list;
       BoxedEvalueList<executorch::aten::Tensor> as_tensor_list;
-      BoxedEvalueList<executorch::aten::optional<executorch::aten::Tensor>>
+      BoxedEvalueList<std::optional<executorch::aten::Tensor>>
           as_list_optional_tensor;
     } copyable_union;
 
@@ -267,11 +266,10 @@ struct EValue {
 
   bool isString() const { return tag == Tag::String; }
 
-  executorch::aten::string_view toString() const {
+  std::string_view toString() const {
     ET_CHECK_MSG(isString(), "EValue is not a String.");
-    return executorch::aten::string_view(
-        payload.copyable_union.as_string.data(),
-        payload.copyable_union.as_string.size());
+    return std::string_view(payload.copyable_union.as_string.data(),
+                            payload.copyable_union.as_string.size());
   }
 
   /****** Int List Type ******/
@@ -326,15 +324,14 @@ struct EValue {
 
   /****** List Optional Tensor Type ******/
   /*implicit*/ EValue(
-      BoxedEvalueList<executorch::aten::optional<executorch::aten::Tensor>> t)
+      BoxedEvalueList<std::optional<executorch::aten::Tensor>> t)
       : tag(Tag::ListOptionalTensor) {
     payload.copyable_union.as_list_optional_tensor = t;
   }
 
   bool isListOptionalTensor() const { return tag == Tag::ListOptionalTensor; }
 
-  executorch::aten::ArrayRef<
-      executorch::aten::optional<executorch::aten::Tensor>>
+  executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>
   toListOptionalTensor() const {
     return payload.copyable_union.as_list_optional_tensor.get();
   }
@@ -377,8 +374,7 @@ struct EValue {
    * Converts the EValue to an optional object that can represent both T and
    * an uninitialized state.
    */
-  template <typename T>
-  inline executorch::aten::optional<T> toOptional() const {
+  template <typename T> inline std::optional<T> toOptional() const {
     if (this->isNone()) {
       return executorch::aten::nullopt;
     }
@@ -458,44 +454,42 @@ EVALUE_DEFINE_TO(executorch::aten::Scalar, toScalar)
 EVALUE_DEFINE_TO(int64_t, toInt)
 EVALUE_DEFINE_TO(bool, toBool)
 EVALUE_DEFINE_TO(double, toDouble)
-EVALUE_DEFINE_TO(executorch::aten::string_view, toString)
+EVALUE_DEFINE_TO(std::string_view, toString)
 EVALUE_DEFINE_TO(executorch::aten::ScalarType, toScalarType)
 EVALUE_DEFINE_TO(executorch::aten::MemoryFormat, toMemoryFormat)
 EVALUE_DEFINE_TO(executorch::aten::Layout, toLayout)
 EVALUE_DEFINE_TO(executorch::aten::Device, toDevice)
 // Tensor and Optional Tensor
-EVALUE_DEFINE_TO(executorch::aten::optional<executorch::aten::Tensor>,
+EVALUE_DEFINE_TO(std::optional<executorch::aten::Tensor>,
                  toOptional<executorch::aten::Tensor>)
 EVALUE_DEFINE_TO(executorch::aten::Tensor, toTensor)
 
 // IntList and Optional IntList
 EVALUE_DEFINE_TO(executorch::aten::ArrayRef<int64_t>, toIntList)
-EVALUE_DEFINE_TO(
-    executorch::aten::optional<executorch::aten::ArrayRef<int64_t>>,
-    toOptional<executorch::aten::ArrayRef<int64_t>>)
+EVALUE_DEFINE_TO(std::optional<executorch::aten::ArrayRef<int64_t>>,
+                 toOptional<executorch::aten::ArrayRef<int64_t>>)
 
 // DoubleList and Optional DoubleList
 EVALUE_DEFINE_TO(executorch::aten::ArrayRef<double>, toDoubleList)
-EVALUE_DEFINE_TO(executorch::aten::optional<executorch::aten::ArrayRef<double>>,
+EVALUE_DEFINE_TO(std::optional<executorch::aten::ArrayRef<double>>,
                  toOptional<executorch::aten::ArrayRef<double>>)
 
 // BoolList and Optional BoolList
 EVALUE_DEFINE_TO(executorch::aten::ArrayRef<bool>, toBoolList)
-EVALUE_DEFINE_TO(executorch::aten::optional<executorch::aten::ArrayRef<bool>>,
+EVALUE_DEFINE_TO(std::optional<executorch::aten::ArrayRef<bool>>,
                  toOptional<executorch::aten::ArrayRef<bool>>)
 
 // TensorList and Optional TensorList
 EVALUE_DEFINE_TO(executorch::aten::ArrayRef<executorch::aten::Tensor>,
                  toTensorList)
 EVALUE_DEFINE_TO(
-    executorch::aten::optional<
-        executorch::aten::ArrayRef<executorch::aten::Tensor>>,
+    std::optional<executorch::aten::ArrayRef<executorch::aten::Tensor>>,
     toOptional<executorch::aten::ArrayRef<executorch::aten::Tensor>>)
 
 // List of Optional Tensor
-EVALUE_DEFINE_TO(executorch::aten::ArrayRef<
-                     executorch::aten::optional<executorch::aten::Tensor>>,
-                 toListOptionalTensor)
+EVALUE_DEFINE_TO(
+    executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>,
+    toListOptionalTensor)
 #undef EVALUE_DEFINE_TO
 
 template <typename T>

package/third-party/include/executorch/runtime/core/event_tracer.h

@@ -26,10 +26,14 @@ typedef int32_t ChainID;
 /// Represents the debug handle that is generally associated with each
 /// op executed in the runtime.
 typedef uint32_t DebugHandle;
+// Represents the delegate debug id that is generally associated with each
+// delegate event.
+typedef int32_t DelegateDebugIntId;
 
 /// Default id's for chain id and debug handle.
 constexpr ChainID kUnsetChainId = -1;
 constexpr DebugHandle kUnsetDebugHandle = 0;
+constexpr DelegateDebugIntId kUnsetDelegateDebugIntId = -1;
 // Default bundled input index to indicate that it hasn't been set yet.
 constexpr int kUnsetBundledInputIndex = -1;
 
@@ -96,13 +100,14 @@ public:
    *         - False if the event does not match or is unknown.
    *         - An error code if an error occurs during filtering.
    */
-  virtual Result<bool> filter(char *name, DebugHandle delegate_debug_index);
+  virtual Result<bool> filter(const char *name,
+                              DelegateDebugIntId delegate_debug_index) = 0;
 
   /**
    * Virtual destructor for the EventTracerFilterBase class.
    * Ensures proper cleanup of derived class objects.
    */
-  virtual ~EventTracerFilterBase();
+  virtual ~EventTracerFilterBase() = default;
 };
 
 /**
@@ -122,6 +127,11 @@ enum class EventTracerProfilingLevel {
  * started. This is used to uniquely identify that profiling event and will be
  * required to be passed into the end_profiling call to signal that the event
  * identified by this struct has completed.
+ *
+ * TODO(gasoonjia): Now this struct is mix-used for both delegate and
+ *non-delegate events. In the future we should separate them into two different
+ *structs: EventTracerEntry for non-delegate events holding DebugHandle, and
+ *DelegateEventTracerEntry for delegate events holding DelegateDebugIntId.
  **/
 struct EventTracerEntry {
   /// An event id to uniquely identify this event that was generated during a
@@ -207,7 +217,7 @@ public:
    */
   virtual EventTracerEntry
   start_profiling_delegate(const char *name,
-                           DebugHandle delegate_debug_index) = 0;
+                           DelegateDebugIntId delegate_debug_index) = 0;
 
   /**
    * Signal the end of the delegate profiling event contained in
@@ -253,7 +263,7 @@ public:
    * @param[in] metadata_len Length of the metadata buffer.
    */
   virtual void log_profiling_delegate(const char *name,
-                                      DebugHandle delegate_debug_index,
+                                      DelegateDebugIntId delegate_debug_index,
                                       et_timestamp_t start_time,
                                       et_timestamp_t end_time,
                                       const void *metadata = nullptr,
@@ -299,9 +309,12 @@ public:
    * @param[in] evalue The value to be logged.
    * @param[in] evalue_type Indicates what type of output this is logging e.g.
    * an intermediate output, program output etc.
+   * @return A Result<bool> indicating the status of the logging operation.
+   *         - True if the evalue output was successfully logged.
+   *         - An error code if an error occurs during logging.
    */
-  virtual void log_evalue(const EValue &evalue,
-                          LoggedEValueType evalue_type) = 0;
+  virtual Result<bool> log_evalue(const EValue &evalue,
+                                  LoggedEValueType evalue_type) = 0;
 
   /**
    * Log an intermediate tensor output from a delegate.
@@ -324,7 +337,7 @@ public:
    */
   virtual Result<bool>
   log_intermediate_output_delegate(const char *name,
-                                   DebugHandle delegate_debug_index,
+                                   DelegateDebugIntId delegate_debug_index,
                                    const executorch::aten::Tensor &output) = 0;
 
   /**
@@ -348,7 +361,7 @@ public:
    *         - An error code if an error occurs during logging.
    */
   virtual Result<bool> log_intermediate_output_delegate(
-      const char *name, DebugHandle delegate_debug_index,
+      const char *name, DelegateDebugIntId delegate_debug_index,
       const ArrayRef<executorch::aten::Tensor> output) = 0;
 
   /**
@@ -372,7 +385,7 @@ public:
    */
   virtual Result<bool>
   log_intermediate_output_delegate(const char *name,
-                                   DebugHandle delegate_debug_index,
+                                   DelegateDebugIntId delegate_debug_index,
                                    const int &output) = 0;
 
   /**
@@ -396,7 +409,7 @@ public:
    */
   virtual Result<bool>
   log_intermediate_output_delegate(const char *name,
-                                   DebugHandle delegate_debug_index,
+                                   DelegateDebugIntId delegate_debug_index,
                                    const bool &output) = 0;
 
   /**
@@ -420,9 +433,15 @@ public:
    */
   virtual Result<bool>
   log_intermediate_output_delegate(const char *name,
-                                   DebugHandle delegate_debug_index,
+                                   DelegateDebugIntId delegate_debug_index,
                                    const double &output) = 0;
 
+  /**
+   * Set the filter of event tracer for delegation intermediate outputs.
+   */
+  virtual void set_delegation_intermediate_output_filter(
+      EventTracerFilterBase *event_tracer_filter) = 0;
+
   /**
    * Helper function to set the chain id ands debug handle. Users have two
    * options, the first is that they can directly pass in the chain id and debug
@@ -495,12 +514,6 @@ public:
     event_tracer_profiling_level_ = profiling_level;
   }
 
-  /**
-   * Set the filter of event tracer for delegation intermediate outputs.
-   */
-  void set_delegation_intermediate_output_filter(
-      EventTracerFilterBase *event_tracer_filter);
-
   /**
    * Return the current level of event tracer profiling.
    */
@@ -554,12 +567,14 @@ using ::executorch::runtime::AllocatorID;
 using ::executorch::runtime::ChainID;
 using ::executorch::runtime::DebugHandle;
 using ::executorch::runtime::DelegateDebugIdType;
+using ::executorch::runtime::DelegateDebugIntId;
 using ::executorch::runtime::EventTracer;
 using ::executorch::runtime::EventTracerDebugLogLevel;
 using ::executorch::runtime::EventTracerEntry;
 using ::executorch::runtime::kUnsetBundledInputIndex;
 using ::executorch::runtime::kUnsetChainId;
 using ::executorch::runtime::kUnsetDebugHandle;
+using ::executorch::runtime::kUnsetDelegateDebugIntId;
 using ::executorch::runtime::LoggedEValueType;
 } // namespace executor
 } // namespace torch

package/third-party/include/executorch/runtime/core/event_tracer_hooks.h

@@ -30,7 +30,7 @@
  */
 
 namespace executorch {
-namespace runtime {
+namespace ET_RUNTIME_NAMESPACE {
 namespace internal {
 
 /**
@@ -297,7 +297,7 @@ inline void event_tracer_set_bundled_input_index(EventTracer *event_tracer,
 }
 
 } // namespace internal
-} // namespace runtime
+} // namespace ET_RUNTIME_NAMESPACE
 } // namespace executorch
 
 namespace torch {
@@ -305,18 +305,27 @@ namespace executor {
 namespace internal {
 // TODO(T197294990): Remove these deprecated aliases once all users have moved
 // to the new `::executorch` namespaces.
-using ::executorch::runtime::internal::event_tracer_begin_profiling_event;
-using ::executorch::runtime::internal::event_tracer_create_event_block;
-using ::executorch::runtime::internal::event_tracer_end_profiling_event;
-using ::executorch::runtime::internal::event_tracer_log_evalue;
-using ::executorch::runtime::internal::event_tracer_log_evalue_output;
-using ::executorch::runtime::internal::event_tracer_set_bundled_input_index;
-using ::executorch::runtime::internal::event_tracer_track_allocation;
-using ::executorch::runtime::internal::event_tracer_track_allocator;
-using ::executorch::runtime::internal::EventTracerProfileInstructionScope;
-using ::executorch::runtime::internal::EventTracerProfileMethodScope;
-using ::executorch::runtime::internal::EventTracerProfileOpScope;
-using ::executorch::runtime::internal::EventTracerProfileScope;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    event_tracer_begin_profiling_event;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    event_tracer_create_event_block;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    event_tracer_end_profiling_event;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::event_tracer_log_evalue;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    event_tracer_log_evalue_output;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    event_tracer_set_bundled_input_index;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    event_tracer_track_allocation;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    event_tracer_track_allocator;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    EventTracerProfileInstructionScope;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::
+    EventTracerProfileMethodScope;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::EventTracerProfileOpScope;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::EventTracerProfileScope;
 
 } // namespace internal
 } // namespace executor

package/third-party/include/executorch/runtime/core/exec_aten/exec_aten.h

@@ -47,21 +47,37 @@
 
 #endif
 
+/**
+ * This hack is for separating out ATen mode vs non-ATen mode. In ATen mode,
+ * we use the ATen types directly. In non-ATen mode, we use the portable types.
+ * To avoid duplicate symbols and/or duplicate operator registration, when a
+ * user depends on both the ATen mode and non-ATen mode versions of the
+ * ExecuTorch library.
+ */
+#ifndef ET_RUNTIME_NAMESPACE
+#if defined(USE_ATEN_LIB)
+#define ET_RUNTIME_NAMESPACE runtime::aten
+#else
+#define ET_RUNTIME_NAMESPACE runtime
+#endif
+#endif
+
 namespace executorch {
 namespace aten {
 
 using TensorShapeDynamism = executorch::runtime::TensorShapeDynamism;
 
+using std::nullopt;
+using std::nullopt_t;
+using std::optional;
+using std::string_view;
+
 #ifdef USE_ATEN_LIB
 
 using Tensor = at::Tensor;
 using TensorList = at::TensorList;
 using TensorImpl = at::TensorImpl;
-using string_view = std::string_view;
 template <typename T> using ArrayRef = c10::ArrayRef<T>;
-template <typename T> using optional = std::optional<T>;
-using nullopt_t = std::nullopt_t;
-using std::nullopt;
 using ScalarType = at::ScalarType;
 using Scalar = c10::Scalar;
 using MemoryFormat = c10::MemoryFormat;
@@ -91,16 +107,23 @@ inline ssize_t compute_numel(const SizesType *sizes, ssize_t dim) {
       c10::multiply_integers(c10::ArrayRef<SizesType>(sizes, dim)));
 }
 
+#undef ET_PRI_TENSOR_SIZE
+#define ET_PRI_TENSOR_SIZE PRId64
+
+#undef ET_PRI_TENSOR_DIM
+#define ET_PRI_TENSOR_DIM PRId64
+
+#undef ET_PRI_TENSOR_NUMEL
+#define ET_PRI_TENSOR_NUMEL PRId64
+
+#undef ET_PRI_SIZES_AND_STRIDES
+#define ET_PRI_SIZES_AND_STRIDES PRId64
+
 #else // Use executor types
 
 using Tensor = torch::executor::Tensor;
 using TensorImpl = torch::executor::TensorImpl;
-using string_view = torch::executor::string_view;
 template <typename T> using ArrayRef = torch::executor::ArrayRef<T>;
-template <typename T> using optional = torch::executor::optional<T>;
-using nullopt_t = torch::executor::nullopt_t;
-// NOLINTNEXTLINE(facebook-hte-NamespaceScopedStaticDeclaration)
-using std::nullopt;
 using ScalarType = torch::executor::ScalarType;
 using TensorList = ArrayRef<Tensor>;
 using Scalar = torch::executor::Scalar;

package/third-party/include/executorch/runtime/core/exec_aten/util/dim_order_util.h

@@ -13,6 +13,7 @@
 #include <cstdio>
 #include <cstring>
 
+#include <c10/util/irange.h>
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/platform/assert.h>
 #include <executorch/runtime/platform/compiler.h>
@@ -23,7 +24,7 @@ namespace runtime {
 namespace {
 template <typename DimOrderType>
 bool validate_dim_order(const DimOrderType *dim_order, const size_t dims) {
-  for (size_t i = 0; i < dims; ++i) {
+  for (const auto i : c10::irange(dims)) {
     if (dim_order[i] >= static_cast<DimOrderType>(dims)) {
       return false;
     }
@@ -42,7 +43,7 @@ bool validate_dim_order(const DimOrderType *dim_order, const size_t dims) {
 template <typename DimOrderType>
 inline bool is_contiguous_dim_order(const DimOrderType *dim_order,
                                     const size_t dims) {
-  for (size_t i = 0; i < dims; ++i) {
+  for (const auto i : c10::irange(dims)) {
     if (dim_order[i] != static_cast<DimOrderType>(i)) {
       return false;
     }