react-native-executorch 0.5.2 → 0.5.4

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/runtime/core/event_tracer_hooks.h

@@ -1,323 +0,0 @@
-/*
- * 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/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/runtime/core/event_tracer_hooks_delegate.h

@@ -1,197 +0,0 @@
-/*
- * 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/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/runtime/core/exec_aten/exec_aten.h

@@ -1,147 +0,0 @@
-/*
- * 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