react-native-executorch 0.4.7 → 0.5.1-rc.0

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

@@ -0,0 +1,323 @@
+/*
+ * 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 <executorch/runtime/core/event_tracer.h>
+
+/**
+ * @file
+ *
+ * This file contains the hooks that are inserted across various parts of the
+ * core runtime code to call into the EventTracer class for logging of profiling
+ * and debugging events. Any calls made to the EventTracer from the runtime must
+ * be made via these hooks.
+ * Users shouldn't directly add these hooks in their code and it's meant only
+ * for usage in ExecuTorch internal code.
+ *
+ * The benefit of defining these hooks is that we can easily control whether or
+ * not we want to compile in the EventTracer code based on the status of the
+ * ET_EVENT_TRACER_ENABLED flag.
+ *
+ * TODO(dbort): Make this a private header of runtime/executor. It only contains
+ * runtime-internal functions and should not be part of the public set of
+ * headers.
+ */
+
+namespace executorch {
+namespace runtime {
+namespace internal {
+
+/**
+ * This class enables scope based profiling where needed using RAII for
+ * operators only. If operator profiling is disabled then this class is a no-op.
+ */
+class EventTracerProfileOpScope final {
+public:
+  EventTracerProfileOpScope(EventTracer *event_tracer, const char *name) {
+#ifdef ET_EVENT_TRACER_ENABLED
+    event_tracer_ = event_tracer;
+    if (event_tracer_ == nullptr) {
+      return;
+    }
+    if (event_tracer_->event_tracer_profiling_level() >
+        executorch::runtime::EventTracerProfilingLevel::kProfileMethodOnly) {
+      event_entry_ = event_tracer->start_profiling(name);
+    }
+#else //! ET_EVENT_TRACER_ENABLED
+    (void)event_tracer;
+    (void)name;
+#endif
+  }
+
+  ~EventTracerProfileOpScope() {
+#ifdef ET_EVENT_TRACER_ENABLED
+    if (event_tracer_ == nullptr) {
+      return;
+    }
+    if (event_tracer_->event_tracer_profiling_level() >
+        executorch::runtime::EventTracerProfilingLevel::kProfileMethodOnly) {
+      event_tracer_->end_profiling(event_entry_);
+    }
+#endif
+  }
+
+private:
+#ifdef ET_EVENT_TRACER_ENABLED
+  EventTracer *event_tracer_;
+  EventTracerEntry event_entry_;
+#endif
+};
+
+using EventTracerProfileScope = EventTracerProfileOpScope;
+
+/**
+ * This class enables scope based profiling where needed using RAII.
+ * Profiling will be started when the object is created and will end
+ * when the object goes out of scope. This is specifically intended to
+ * be used for profiling methods in the runtime.
+ */
+class EventTracerProfileMethodScope final {
+public:
+  EventTracerProfileMethodScope(EventTracer *event_tracer, const char *name) {
+#ifdef ET_EVENT_TRACER_ENABLED
+    event_tracer_ = event_tracer;
+    if (event_tracer_ == nullptr) {
+      return;
+    }
+    event_entry_ = event_tracer->start_profiling(name);
+#else //! ET_EVENT_TRACER_ENABLED
+    (void)event_tracer;
+    (void)name;
+#endif
+  }
+
+  ~EventTracerProfileMethodScope() {
+#ifdef ET_EVENT_TRACER_ENABLED
+    if (event_tracer_ == nullptr) {
+      return;
+    }
+    event_tracer_->end_profiling(event_entry_);
+#endif
+  }
+
+private:
+#ifdef ET_EVENT_TRACER_ENABLED
+  EventTracer *event_tracer_;
+  EventTracerEntry event_entry_;
+#endif
+};
+
+/**
+ * This class helps us set and then clear out the chain id and debug handle
+ * values stored in the event tracer class using RAII. This is typically called
+ * in the executor loop before entering the codegen layer to configure the chain
+ * id and debug handle of the current instruction being executed.
+ * After we return from the kernel execution we can then reset the chain id and
+ * debug handle to defaults when this object goes out of scope.
+ */
+class EventTracerProfileInstructionScope final {
+public:
+  EventTracerProfileInstructionScope(EventTracer *event_tracer,
+                                     ChainID chain_idx,
+                                     DebugHandle debug_handle) {
+#ifdef ET_EVENT_TRACER_ENABLED
+    event_tracer_ = event_tracer;
+    if (event_tracer_ == nullptr) {
+      return;
+    }
+    event_tracer_->set_chain_debug_handle(chain_idx, debug_handle);
+#else //! ET_EVENT_TRACER_ENABLED
+    (void)event_tracer;
+    (void)chain_idx;
+    (void)debug_handle;
+#endif
+  }
+
+  ~EventTracerProfileInstructionScope() {
+#ifdef ET_EVENT_TRACER_ENABLED
+    if (event_tracer_ == nullptr) {
+      return;
+    }
+    event_tracer_->set_chain_debug_handle(kUnsetChainId, kUnsetDebugHandle);
+#endif
+  }
+
+private:
+#ifdef ET_EVENT_TRACER_ENABLED
+  EventTracer *event_tracer_;
+#endif
+};
+
+inline bool event_tracer_enabled() {
+#ifdef ET_EVENT_TRACER_ENABLED
+  return true;
+#else //! ET_EVENT_TRACER_ENABLED
+  return false;
+#endif
+}
+/**
+ * Create a new event block with the specified name. Any events logged
+ * after this will be associated with this new event block.
+ */
+inline void event_tracer_create_event_block(EventTracer *event_tracer,
+                                            char const *name) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    event_tracer->create_event_block(name);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)name;
+#endif
+}
+
+/**
+ * Explicitly mark the beginning of a new profiling event. This returns
+ * an instance of an EventTracerEntry object that the user needs to keep
+ * around and pass into the corresponding event_tracer_end_profiling_event
+ * call.
+ */
+inline EventTracerEntry
+event_tracer_begin_profiling_event(EventTracer *event_tracer,
+                                   char const *name) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    return event_tracer->start_profiling(name);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)name;
+#endif
+  // There is no active tracer; this value will be ignored.
+  return EventTracerEntry();
+}
+
+/**
+ * Mark the end of a profiling event passing in the entry token
+ * returned by a previous call to ET_EVENT_TRACER_BEGIN_PROFILING_EVENT.
+ */
+inline void event_tracer_end_profiling_event(EventTracer *event_tracer,
+                                             EventTracerEntry event) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    event_tracer->end_profiling(event);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)event;
+#endif
+}
+
+/**
+ * Start the tracking of the allocator represented by this name and returns
+ * an AllocatorID that will be used to track all subsequent allocations done by
+ * this allocator.
+ */
+inline AllocatorID event_tracer_track_allocator(EventTracer *event_tracer,
+                                                const char *name) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    return event_tracer->track_allocator(name);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)name;
+#endif
+  // There is no active tracer; this value will be ignored.
+  return 0;
+}
+
+/// Log the allocation event done via the allocator represented by id.
+inline void event_tracer_track_allocation(EventTracer *event_tracer,
+                                          AllocatorID id, size_t size) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    event_tracer->track_allocation(id, size);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)id;
+  (void)size;
+#endif
+}
+
+/// Log an intermediate value.
+inline void event_tracer_log_evalue(EventTracer *event_tracer, EValue &evalue) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    if (event_tracer->event_tracer_debug_level() >=
+        EventTracerDebugLogLevel::kIntermediateOutputs) {
+      event_tracer->log_evalue(evalue, LoggedEValueType::kIntermediateOutput);
+    }
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)evalue;
+#endif
+}
+
+/// Log a program output.
+inline void event_tracer_log_evalue_output(EventTracer *event_tracer,
+                                           const EValue &evalue) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  /*
+   * If debugging via event tracer is enabled but intermediate output logging is
+   * disabled then we want to only log the outputs.
+   */
+  if (event_tracer) {
+    if (event_tracer->event_tracer_debug_level() >=
+        EventTracerDebugLogLevel::kProgramOutputs) {
+      event_tracer->log_evalue(evalue, LoggedEValueType::kProgramOutput);
+    }
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)evalue;
+#endif
+}
+
+// Set the bundled input index of the current bundled input being used by the
+// method.
+inline void event_tracer_set_bundled_input_index(EventTracer *event_tracer,
+                                                 int bundled_input_index) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    event_tracer->set_bundled_input_index(bundled_input_index);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer;
+  (void)bundled_input_index;
+#endif
+}
+
+} // namespace internal
+} // namespace runtime
+} // namespace executorch
+
+namespace torch {
+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;
+
+} // namespace internal
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,197 @@
+/*
+ * 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 <executorch/runtime/core/event_tracer.h>
+
+/**
+ * @file
+ *
+ * This file contains the hooks that can be used by runtime delegate backend
+ * authors to log profiling and debugging events from backend code. In order to
+ * use these hooks delegate authors would have needed to generate a delegate
+ * debug identifier mapping using the DelegateMappingBuilder library present in
+ * executorch/exir/backend/utils.py. The delegate debug identifiers generated by
+ * that library are the ones that need to be passed to these hooks to log
+ * events. Using any other identifiers will cause post-processing of the events
+ * data to not properly link back to the nodes in the original lowered graph.
+ *
+ * The benefit of defining these hooks is that we can easily control whether or
+ * not we want to compile in the EventTracer code based on the status of the
+ * ET_EVENT_TRACER_ENABLED flag.
+ */
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Start the profiling of a delegate event. Similar to start_profiling it will
+ * return an instance of EventTracerEntry that contains the details of this
+ * event. Can be left in production code as these hooks compile conditionally.
+ *
+ * @param[in] event_tracer The event tracer instance that is doing the logging.
+ * @param[in] name Human readable name for the delegate event. This name has
+ * to be the same name that was passed in during the Debug delegate mapping
+ * generation in the export/ahead-of-time process. If indices and not names
+ * are used by this delegate to identify ops executed in the backend then
+ * nullptr can be passed in. Users calling this interface do not need to keep
+ * the memory pointed to by this pointer around. The string must be copied over
+ * into internal memory during this call.
+ * @param[in] delegate_debug_id The id of the delegate event. If string
+ * based names are used by this delegate to identify ops executed in the
+ * backend then kUnsetDebugHandle should be passed in here.
+ */
+inline EventTracerEntry
+event_tracer_start_profiling_delegate(EventTracer *event_tracer,
+                                      const char *name,
+                                      DebugHandle delegate_debug_id) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    return event_tracer->start_profiling_delegate(name, delegate_debug_id);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)name;
+  (void)delegate_debug_id;
+#endif
+  // There is no active tracer; this value will be ignored.
+  return EventTracerEntry();
+}
+
+/**
+ * Signal the end of the delegate profiling event contained in
+ * event_tracer_entry. Users also have the option to log some some free-from
+ * string based metadata along with this. Can be left in production code as
+ * these hooks compile conditionally.
+ *
+ * @param[in] event_tracer The event tracer instance that is doing the logging.
+ * @param[in] event_tracer_entry The EventTracerEntry returned by a call to
+ * start_profiling_delegate().
+ * @param[in] metadata Optional data relevant to the execution that the user
+ * wants to log along with this event. Pointer to metadata doesn't need to be
+ * valid after the call to this function. The contents and format of the data
+ * are transparent to the event tracer. It will just pipe along the data and
+ * make it available for the user again in the post-processing stage.
+ * @param[in] metadata_len Length of the metadata buffer.
+ */
+inline void event_tracer_end_profiling_delegate(
+    EventTracer *event_tracer, EventTracerEntry event_tracer_entry,
+    const void *metadata = nullptr, size_t metadata_len = 0) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    event_tracer->end_profiling_delegate(event_tracer_entry, metadata,
+                                         metadata_len);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)event_tracer_entry;
+  (void)metadata;
+  (void)metadata_len;
+#endif
+}
+
+/**
+ * Some delegates get access to the profiling details only after the complete
+ * graph has been executed. This interface is to support such use cases. It
+ * can be called in a loop etc. to log any number of profiling events that are
+ * part of this delegate. Can be left in production code as these hooks
+ * compile conditionally.
+ *
+ * @param[in] event_tracer The event tracer instance that is doing the logging.
+ * @param[in] name Human readable name for the delegate event. This name has
+ * to be the same name that was passed in during the Debug delegate mapping
+ * generation in the export/ahead-of-time process. If indices and not names
+ * are used by this delegate to identify ops executed in the backend then
+ * nullptr can be passed in. Users calling this interface do not need to keep
+ * the memory pointed to by this pointer around. The string must
+ * be copied over into internal memory during this call.
+ * @param[in] delegate_debug_id The id of the delegate event. If string
+ * based names are used by this delegate to identify ops executed in the
+ * backend then -1 should be passed in here.
+ * @param[in] start_time The timestamp when the delegate event started.
+ * @param[in] end_time The timestamp when the delegate event finished.
+ * @param[in] metadata Optional data relevant to the execution that the user
+ * wants to log along with this event. Pointer to metadata doesn't need to be
+ * valid after the call to this function. The contents and format of the data
+ * are transparent to the event tracer. It will just pipe along the data and
+ * make it available for the user again in the post-processing stage.
+ * @param[in] metadata_len Length of the metadata buffer.
+ */
+inline void event_tracer_log_profiling_delegate(
+    EventTracer *event_tracer, const char *name, DebugHandle delegate_debug_id,
+    et_timestamp_t start_time, et_timestamp_t end_time,
+    const void *metadata = nullptr, size_t metadata_len = 0) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    event_tracer->log_profiling_delegate(name, delegate_debug_id, start_time,
+                                         end_time, metadata, metadata_len);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)name;
+  (void)delegate_debug_id;
+  (void)start_time;
+  (void)end_time;
+  (void)metadata;
+  (void)metadata_len;
+#endif
+}
+
+/**
+ * This templated interfaces can be called in a loop etc. to log any number of
+ * debug events that are part of this delegate. Supported values types are int,
+ * bool, double, tensor and array of tensors. Can be left in production code as
+ * these hooks compile conditionally.
+ *
+ * @param[in] event_tracer The event tracer instance that is doing the logging.
+ * @param[in] name Human readable name for the delegate event. This name has
+ * to be the same name that was passed in during the Debug delegate mapping
+ * generation in the export/ahead-of-time process. If indices and not names
+ * are used by this delegate to identify ops executed in the backend then
+ * nullptr can be passed in. Users calling this interface do not need to keep
+ * the memory pointed to by this pointer around. The string must
+ * be copied over into internal memory during this call.
+ * @param[in] delegate_debug_id The id of the delegate event. If string
+ * based names are used by this delegate to identify ops executed in the
+ * backend then -1 should be passed in here.
+ * @param[in] output The output to be logged.
+ */
+template <typename T>
+inline void event_tracer_log_output_delegate(EventTracer *event_tracer,
+                                             const char *name,
+                                             DebugHandle delegate_debug_id,
+                                             const T &output) {
+#ifdef ET_EVENT_TRACER_ENABLED
+  if (event_tracer) {
+    static_assert(
+        std::is_same<T, int>::value || std::is_same<T, bool>::value ||
+            std::is_same<T, double>::value ||
+            std::is_same<T, executorch::aten::Tensor>::value ||
+            std::is_same<T, ArrayRef<executorch::aten::Tensor>>::value,
+        "Unsupported type for intermediate output");
+    event_tracer->log_intermediate_output_delegate(name, delegate_debug_id,
+                                                   output);
+  }
+#else //! ET_EVENT_TRACER_ENABLED
+  (void)name;
+  (void)delegate_debug_id;
+  (void)output;
+#endif
+}
+
+} // namespace runtime
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::runtime::event_tracer_end_profiling_delegate;
+using ::executorch::runtime::event_tracer_log_output_delegate;
+using ::executorch::runtime::event_tracer_log_profiling_delegate;
+using ::executorch::runtime::event_tracer_start_profiling_delegate;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,147 @@
+/*
+ * 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 <executorch/runtime/core/tensor_shape_dynamism.h> // @manual
+#include <executorch/runtime/platform/compiler.h>
+#ifdef USE_ATEN_LIB
+#include <ATen/Tensor.h> // @manual
+#include <c10/core/Device.h>
+#include <c10/core/DeviceType.h>    // @manual
+#include <c10/core/Layout.h>        // @manual
+#include <c10/core/MemoryFormat.h>  // @manual
+#include <c10/core/Scalar.h>        // @manual
+#include <c10/util/ArrayRef.h>      // @manual
+#include <c10/util/BFloat16-math.h> // @manual
+#include <c10/util/BFloat16.h>      // @manual
+#include <c10/util/Half.h>          // @manual
+#include <c10/util/Optional.h>      // @manual
+#include <c10/util/complex.h>       // @manual
+#include <c10/util/qint32.h>        // @manual
+#include <c10/util/qint8.h>         // @manual
+#include <c10/util/quint2x4.h>      // @manual
+#include <c10/util/quint4x2.h>      // @manual
+#include <c10/util/quint8.h>        // @manual
+#include <c10/util/string_view.h>   // @manual
+#include <torch/torch.h>
+#else                                                            // use executor
+#include <executorch/runtime/core/array_ref.h>                   // @manual
+#include <executorch/runtime/core/portable_type/bfloat16.h>      // @manual
+#include <executorch/runtime/core/portable_type/bfloat16_math.h> // @manual
+#include <executorch/runtime/core/portable_type/complex.h>       // @manual
+#include <executorch/runtime/core/portable_type/device.h>        // @manual
+#include <executorch/runtime/core/portable_type/half.h>          // @manual
+#include <executorch/runtime/core/portable_type/optional.h>      // @manual
+#include <executorch/runtime/core/portable_type/qint_types.h>    // @manual
+#include <executorch/runtime/core/portable_type/scalar.h>        // @manual
+#include <executorch/runtime/core/portable_type/scalar_type.h>   // @manual
+#include <executorch/runtime/core/portable_type/string_view.h>   // @manual
+#include <executorch/runtime/core/portable_type/tensor.h>        // @manual
+#include <executorch/runtime/core/portable_type/tensor_options.h> // @manual
+
+#endif
+
+namespace executorch {
+namespace aten {
+
+using TensorShapeDynamism = executorch::runtime::TensorShapeDynamism;
+
+#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;
+using SizesType = int64_t;
+using DimOrderType = uint8_t;
+using StridesType = int64_t;
+using Device = c10::Device;
+using DeviceType = c10::DeviceType;
+using Layout = c10::Layout;
+
+// Custom types that map to ScalarType
+using Half = c10::Half;
+template <typename T> using complex = c10::complex<T>;
+using qint8 = c10::qint8;
+using quint8 = c10::quint8;
+using qint32 = c10::qint32;
+using BFloat16 = c10::BFloat16;
+using quint4x2 = c10::quint4x2;
+using quint2x4 = c10::quint2x4;
+using IntArrayRef = at::IntArrayRef;
+
+template <typename T> using OptionalArrayRef = c10::OptionalArrayRef<T>;
+using OptionalIntArrayRef = OptionalArrayRef<int64_t>;
+
+inline ssize_t compute_numel(const SizesType *sizes, ssize_t dim) {
+  return static_cast<ssize_t>(
+      c10::multiply_integers(c10::ArrayRef<SizesType>(sizes, dim)));
+}
+
+#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;
+using MemoryFormat = torch::executor::MemoryFormat;
+using SizesType = torch::executor::Tensor::SizesType;
+using DimOrderType = torch::executor::Tensor::DimOrderType;
+using StridesType = torch::executor::Tensor::StridesType;
+using Device = torch::executor::Device;
+using DeviceType = torch::executor::DeviceType;
+using Layout = torch::executor::Layout;
+
+// Custom types that map to ScalarType
+using Half = torch::executor::Half;
+template <typename T> using complex = torch::executor::complex<T>;
+using qint8 = torch::executor::qint8;
+using quint8 = torch::executor::quint8;
+using qint32 = torch::executor::qint32;
+using BFloat16 = torch::executor::BFloat16;
+using quint4x2 = torch::executor::quint4x2;
+using quint2x4 = torch::executor::quint2x4;
+
+using IntArrayRef = torch::executor::IntArrayRef;
+
+template <typename T>
+using OptionalArrayRef =
+    torch::executor::optional<torch::executor::ArrayRef<T>>;
+using OptionalIntArrayRef = OptionalArrayRef<int64_t>;
+
+using torch::executor::compute_numel;
+
+#endif // Use ExecuTorch types
+
+} // namespace aten
+} // namespace executorch
+
+// DEPRECATED: The exec_aten:: namespace is deprecated. Use executorch::aten::
+// instead.
+namespace exec_aten = executorch::aten;
+
+namespace torch {
+namespace executor {
+using TensorList = ::executorch::aten::TensorList;
+} // namespace executor
+} // namespace torch