react-native-executorch 0.5.2 → 0.5.3

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64-simulator/Headers/executorch/runtime/backend/backend_execution_context.h

@@ -1,71 +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>
-#include <executorch/runtime/core/memory_allocator.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * BackendExecutionContext will be used to inject run time context.
- */
-class BackendExecutionContext final {
-public:
-  BackendExecutionContext(EventTracer *event_tracer = nullptr,
-                          MemoryAllocator *temp_allocator = nullptr,
-                          const char *method_name = nullptr)
-      : event_tracer_(event_tracer), temp_allocator_(temp_allocator),
-        method_name_(method_name) {}
-
-  /**
-   * Returns a pointer to an instance of EventTracer to do profiling/debugging
-   * logging inside the delegate backend. Users will need access to this pointer
-   * to use any of the event tracer APIs.
-   */
-  EventTracer *event_tracer() { return event_tracer_; }
-
-  /**
-   * Returns a pointer to the address allocated by temp allocator. This
-   * allocator will be reset after every delegate call during execution.
-   */
-  void *allocate(size_t size,
-                 size_t alignment = MemoryAllocator::kDefaultAlignment) {
-    // TODO(chenlai): depends on the need, we may expose more functionality for
-    // memory allocation.
-    return temp_allocator_->allocate(size, alignment);
-  }
-
-  /**
-   * Returns the temp allocator. This allocator will be reset every instruction.
-   */
-  MemoryAllocator *get_temp_allocator() { return temp_allocator_; }
-
-  /**
-   * Get the name of the executing method from the ExecuTorch runtime.
-   */
-  const char *get_method_name() const { return method_name_; }
-
-private:
-  EventTracer *event_tracer_ = nullptr;
-  MemoryAllocator *temp_allocator_ = nullptr;
-  const char *method_name_ = nullptr;
-};
-
-} // 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::BackendExecutionContext;
-} // namespace executor
-} // namespace torch

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64-simulator/Headers/executorch/runtime/backend/backend_init_context.h

@@ -1,72 +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/memory_allocator.h>
-#include <executorch/runtime/core/named_data_map.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * BackendInitContext will be used to inject runtime info for to initialize
- * delegate.
- */
-class BackendInitContext final {
-public:
-  explicit BackendInitContext(MemoryAllocator *runtime_allocator,
-                              EventTracer *event_tracer = nullptr,
-                              const char *method_name = nullptr,
-                              const NamedDataMap *named_data_map = nullptr)
-      : runtime_allocator_(runtime_allocator), method_name_(method_name),
-        named_data_map_(named_data_map) {}
-
-  /** Get the runtime allocator passed from Method. It's the same runtime
-   * executor used by the standard executor runtime and the life span is the
-   * same as the model.
-   */
-  MemoryAllocator *get_runtime_allocator() { return runtime_allocator_; }
-
-  /**
-   * Returns a pointer (null if not installed) to an instance of EventTracer to
-   * do profiling/debugging logging inside the delegate backend. Users will need
-   * access to this pointer to use any of the event tracer APIs.
-   */
-  EventTracer *event_tracer() { return event_tracer_; }
-
-  /** Get the loaded method name from ExecuTorch runtime. Usually it's
-   * "forward", however, if there are multiple methods in the .pte file, it can
-   * be different. One example is that we may have prefill and decode methods in
-   * the same .pte file. In this case, when client loads "prefill" method, the
-   * `get_method_name` function will return "prefill", when client loads
-   * "decode" method, the `get_method_name` function will return "decode".
-   */
-  const char *get_method_name() const { return method_name_; }
-
-  /** Get the named data map from ExecuTorch runtime.
-   * This provides a way for backends to retrieve data blobs by key.
-   */
-  const NamedDataMap *get_named_data_map() const { return named_data_map_; }
-
-private:
-  MemoryAllocator *runtime_allocator_ = nullptr;
-  EventTracer *event_tracer_ = nullptr;
-  const char *method_name_ = nullptr;
-  const NamedDataMap *named_data_map_ = nullptr;
-};
-
-} // 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::BackendInitContext;
-} // namespace executor
-} // namespace torch

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64-simulator/Headers/executorch/runtime/backend/interface.h

@@ -1,166 +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 <cstring>
-
-#include <executorch/runtime/backend/backend_execution_context.h>
-#include <executorch/runtime/backend/backend_init_context.h>
-#include <executorch/runtime/core/array_ref.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/freeable_buffer.h>
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/core/named_data_map.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace runtime {
-
-struct SizedBuffer {
-  void *buffer;
-  size_t nbytes; // number of bytes of buffer
-};
-
-struct CompileSpec {
-  const char *key;   // spec key
-  SizedBuffer value; // spec value
-};
-
-/**
- * An opaque handle managed by a backend. Typically points to a backend-private
- * class/struct.
- */
-using DelegateHandle = void;
-
-class BackendInterface {
-public:
-  virtual ~BackendInterface() = 0;
-
-  /**
-   * Returns true if the backend is available to process delegation calls.
-   */
-  ET_NODISCARD virtual bool is_available() const = 0;
-
-  /**
-   * Responsible to further process (compile/transform/optimize) the compiled
-   * unit that was produced, ahead-of-time, as well as perform any backend
-   * initialization to ready it for execution. This method is called every time
-   * the ExecuTorch program is initialized. Consequently, this is the place to
-   * perform any backend initialization as well as transformations,
-   * optimizations, and even compilation that depend on the target device. As
-   * such, it is strongly encouraged to push as much processing as possible to
-   * the ahead-of-time processing.
-   *
-   * @param[in] processed An opaque (to ExecuTorch) backend-specific compiled
-   *     unit from the preprocessor. Can contain anything the backend needs to
-   *     execute the equivalent semantics of the passed-in Module and its
-   *     method. Often passed unmodified to `execute()` as a `DelegateHandle`,
-   *     unless it needs further processing at init time to be fully executable.
-   *     If the data is not needed after init(), calling processed->Free() can
-   *     reclaim its memory.
-   * @param[in] compile_specs The exact same compiler specification that
-   *     was used ahead-of-time to produce `processed`.
-   *
-   * @returns On success, an opaque handle representing the the method
-   *     implemented by the delegate. This handle is passed to `execute()` and
-   *     `destroy()`, and the memory it points to is owned by the backend.
-   *     Typically points to a backend-private class/struct.
-   * @returns On error, returns an error code other than Error::Ok. If the
-   *     compiled unit (the preprocessed result from ahead of time) is not
-   *     compatible with the current backend runtime, return the error code
-   *     Error::DelegateInvalidCompatibility. Other backend delegate
-   *     specific error codes can be found in error.h.
-   */
-  ET_NODISCARD virtual Result<DelegateHandle *>
-  init(BackendInitContext &context, FreeableBuffer *processed,
-       ArrayRef<CompileSpec> compile_specs) const = 0;
-
-  /**
-   * Responsible for executing the given method’s handle, as it was produced
-   * by compile.
-   *
-   * @param[in] handle An opaque handle returned by `init()`. Usually a backend
-   *     executable unit. This executable unit should be ready to execute the
-   *     delegate blobs.
-   * @param[in] args The method’s inputs and outputs.
-   * @retval Error::Ok if successful.
-   */
-  ET_NODISCARD virtual Error execute(BackendExecutionContext &context,
-                                     DelegateHandle *handle,
-                                     EValue **args) const = 0;
-
-  /**
-   * Responsible for destroying a handle, if it's required for some backend.
-   * It may be needed for some backends. For example, resources associated with
-   * this handle needs to be released. This method is called when the execution
-   * plan is destroyed (i.e., the program is out of its lifespan).
-   *
-   * @param[in] handle The handle to be destroyed. An opaque handle returned by
-   *     `init()`.
-   */
-  virtual void destroy(ET_UNUSED DelegateHandle *handle) const {}
-};
-
-/**
- * Returns the corresponding object pointer for a given string name.
- * The mapping is populated using register_backend method.
- *
- * @param[in] name Name of the user-defined backend delegate.
- * @retval Pointer to the appropriate object that implements BackendInterface.
- *         Nullptr if it can't find anything with the given name.
- */
-BackendInterface *get_backend_class(const char *name);
-
-/**
- * A named instance of a backend.
- */
-struct Backend {
-  /// The name of the backend. Must match the string used in the PTE file.
-  const char *name;
-  /// The instance of the backend to use when loading and executing programs.
-  BackendInterface *backend;
-};
-
-/**
- * Registers the Backend object (i.e. string name and BackendInterface pair) so
- * that it could be called via the name during the runtime.
- *
- * @param[in] backend Backend object
- * @retval Error code representing whether registration was successful.
- */
-ET_NODISCARD Error register_backend(const Backend &backend);
-
-/**
- * Returns the number of registered backends.
- */
-size_t get_num_registered_backends();
-
-/**
- * Returns the backend name at the given index.
- */
-Result<const char *> get_backend_name(size_t index);
-
-} // 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::Backend;
-using ::executorch::runtime::CompileSpec;
-using ::executorch::runtime::DelegateHandle;
-using ::executorch::runtime::get_backend_class;
-using ::executorch::runtime::register_backend;
-using ::executorch::runtime::SizedBuffer;
-using PyTorchBackendInterface = ::executorch::runtime::BackendInterface;
-} // namespace executor
-} // namespace torch

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

@@ -1,235 +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.
- */
-
-//===--- ArrayRef.h - Array Reference Wrapper -------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// removed llvm-specific functionality
-// removed some implicit const -> non-const conversions that rely on
-// complicated std::enable_if meta-programming
-// removed a bunch of slice variants for simplicity...
-// remove constructors and operators for std::vector
-// removed some prevention of accidental assignments from temporary that
-// required std::enable_if meta-programming
-// removed reverse iterator
-
-#pragma once
-
-#include <array>
-#include <cstdint>
-
-#include <c10/util/irange.h>
-#include <executorch/runtime/platform/assert.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Represents a constant reference to an array (0 or more elements
- * consecutively in memory), i.e. a start pointer and a length.  It allows
- * various APIs to take consecutive elements easily and conveniently.
- *
- * This class does not own the underlying data, it is expected to be used in
- * situations where the data resides in some other buffer, whose lifetime
- * extends past that of the ArrayRef. For this reason, it is not in general
- * safe to store an ArrayRef.
- *
- * Span and ArrayRef are extrememly similar with the difference being ArrayRef
- * views a list of constant elements and Span views a list of mutable elements.
- * Clients should decide between the two based on if the list elements for their
- * use case should be mutable.
- *
- * This is intended to be trivially copyable, so it should be passed by
- * value.
- */
-template <typename T> class ArrayRef final {
-public:
-  using iterator = const T *;
-  using const_iterator = const T *;
-  using size_type = size_t;
-  using value_type = T;
-
-private:
-  /// The start of the array, in an external buffer.
-  const T *Data;
-
-  /// The number of elements.
-  size_type Length;
-
-public:
-  /// @name Constructors
-  /// @{
-
-  /// Construct an empty ArrayRef.
-  /* implicit */ constexpr ArrayRef() : Data(nullptr), Length(0) {}
-
-  /// Construct a ArrayRef from a single element. Implicitly convert element
-  /// type. It is aligned with PyTorch's c10::ArrayRef.
-  /* implicit */ constexpr ArrayRef(const T &OneElt)
-      : Data(&OneElt), Length(1) {}
-
-  /// Construct a ArrayRef from a pointer and length.
-  ArrayRef(const T *data, size_t length) : Data(data), Length(length) {
-    ET_DCHECK(Data != nullptr || Length == 0);
-  }
-
-  /// Construct a ArrayRef from a range.
-  ArrayRef(const T *begin, const T *end) : Data(begin), Length(end - begin) {}
-
-  /// Construct an ArrayRef from a std::array
-  template <size_t N>
-  /* implicit */ constexpr ArrayRef(const std::array<T, N> &Arr)
-      : Data(Arr.data()), Length(N) {}
-
-  /// Construct a ArrayRef from a C array.
-  template <size_t N>
-  /* implicit */ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
-
-  /// @}
-  /// @name Simple Operations
-  /// @{
-
-  constexpr iterator begin() const { return Data; }
-  constexpr iterator end() const { return Data + Length; }
-
-  // These are actually the same as iterator, since ArrayRef only
-  // gives you const iterators.
-  constexpr const_iterator cbegin() const { return Data; }
-  constexpr const_iterator cend() const { return Data + Length; }
-
-  /// empty - Check if the array is empty.
-  constexpr bool empty() const { return Length == 0; }
-
-  constexpr const T *data() const { return Data; }
-
-  /// size - Get the array size.
-  constexpr size_t size() const { return Length; }
-
-  /// front - Get the first element.
-  const T &front() const {
-    // ArrayRef: attempted to access front() of empty list
-    ET_CHECK(!empty());
-    return Data[0];
-  }
-
-  /// back - Get the last element.
-  const T &back() const {
-    // ArrayRef: attempted to access back() of empty list
-    ET_CHECK(!empty());
-    return Data[Length - 1];
-  }
-
-  /// equals - Check for element-wise equality.
-  bool equals(ArrayRef RHS) const {
-    if (Length != RHS.Length) {
-      return false;
-    }
-    for (const auto i : c10::irange(this->Length)) {
-      if (Data[i] != RHS.Data[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /// slice(n, m) - Take M elements of the array starting at element N
-  ArrayRef<T> slice(size_t N, size_t M) const {
-    // cant slice longer then the array
-    ET_CHECK(N + M <= size());
-    return ArrayRef<T>(data() + N, M);
-  }
-
-  /// slice(n) - Chop off the first N elements of the array.
-  constexpr ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
-
-  /// @}
-  /// @name Operator Overloads
-  /// @{
-  constexpr const T &operator[](size_t Index) const { return Data[Index]; }
-
-  /// Vector compatibility
-  const T &at(size_t Index) const {
-    // invalid index
-    ET_CHECK(Index < Length);
-    return Data[Index];
-  }
-
-  /// @}
-};
-
-/// @name ArrayRef Convenience constructors
-/// @{
-
-/// Construct an ArrayRef from a single element.
-template <typename T> ArrayRef<T> makeArrayRef(const T &OneElt) {
-  return OneElt;
-}
-
-/// Construct an ArrayRef from a pointer and length.
-template <typename T> ArrayRef<T> makeArrayRef(const T *data, size_t length) {
-  return ArrayRef<T>(data, length);
-}
-
-/// Construct an ArrayRef from a range.
-template <typename T> ArrayRef<T> makeArrayRef(const T *begin, const T *end) {
-  return ArrayRef<T>(begin, end);
-}
-
-/// Construct an ArrayRef from a std::array.
-template <typename T, std::size_t N>
-ArrayRef<T> makeArrayRef(const std::array<T, N> &Arr) {
-  return Arr;
-}
-
-/// Construct an ArrayRef from an ArrayRef (no-op) (const)
-template <typename T> ArrayRef<T> makeArrayRef(const ArrayRef<T> &Vec) {
-  return Vec;
-}
-
-/// Construct an ArrayRef from an ArrayRef (no-op)
-template <typename T> ArrayRef<T> &makeArrayRef(ArrayRef<T> &Vec) {
-  return Vec;
-}
-
-/// Construct an ArrayRef from a C array.
-template <typename T, size_t N> ArrayRef<T> makeArrayRef(const T (&Arr)[N]) {
-  return ArrayRef<T>(Arr);
-}
-
-// WARNING: Template instantiation will NOT be willing to do an implicit
-// conversions to get you to an ArrayRef, which is why we need so
-// many overloads.
-
-template <typename T> bool operator==(ArrayRef<T> a1, ArrayRef<T> a2) {
-  return a1.equals(a2);
-}
-
-template <typename T> bool operator!=(ArrayRef<T> a1, ArrayRef<T> a2) {
-  return !a1.equals(a2);
-}
-
-using IntArrayRef = ArrayRef<int64_t>;
-
-} // 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::ArrayRef;
-using ::executorch::runtime::IntArrayRef;
-using ::executorch::runtime::makeArrayRef;
-} // namespace executor
-} // namespace torch

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

@@ -1,136 +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 <cstddef>
-
-#include <executorch/runtime/core/freeable_buffer.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Loads from a data source.
- *
- * See //executorch/extension/data_loader for common implementations.
- */
-class DataLoader {
-public:
-  /**
-   * Describes the content of the segment.
-   */
-  struct SegmentInfo {
-    /**
-     * Represents the purpose of the segment.
-     */
-    enum class Type {
-      /**
-       * Data for the actual program.
-       */
-      Program,
-      /**
-       * Holds constant tensor data.
-       */
-      Constant,
-      /**
-       * Data used for initializing a backend.
-       */
-      Backend,
-      /**
-       * Data used for initializing mutable tensors.
-       */
-      Mutable,
-      /**
-       * Data used for initializing external tensors.
-       */
-      External,
-    };
-
-    /// Type of the segment.
-    Type segment_type;
-
-    /// Index of the segment within the segment list. Undefined for program
-    /// segments.
-    size_t segment_index;
-
-    /// An optional, null-terminated string describing the segment. For
-    /// `Backend` segments, this is the backend ID. Null for other segment
-    /// types.
-    const char *descriptor;
-
-    SegmentInfo() = default;
-
-    explicit SegmentInfo(Type segment_type_, size_t segment_index_ = 0,
-                         const char *descriptor_ = nullptr)
-        : segment_type(segment_type_), segment_index(segment_index_),
-          descriptor(descriptor_) {}
-  };
-
-  virtual ~DataLoader() = default;
-
-  /**
-   * Loads data from the underlying data source.
-   *
-   * NOTE: This must be thread-safe. If this call modifies common state, the
-   * implementation must do its own locking.
-   *
-   * @param offset The byte offset in the data source to start loading from.
-   * @param size The number of bytes to load.
-   * @param segment_info Information about the segment being loaded.
-   *
-   * @returns a `FreeableBuffer` that owns the loaded data.
-   */
-  ET_NODISCARD virtual Result<FreeableBuffer>
-  load(size_t offset, size_t size, const SegmentInfo &segment_info) const = 0;
-
-  /**
-   * Loads data from the underlying data source into the provided buffer.
-   *
-   * NOTE: This must be thread-safe. If this call modifies common state, the
-   * implementation must do its own locking.
-   *
-   * @param offset The byte offset in the data source to start loading from.
-   * @param size The number of bytes to load.
-   * @param segment_info Information about the segment being loaded.
-   * @param buffer The buffer to load data into. Must point to at least `size`
-   * bytes of memory.
-   *
-   * @returns an Error indicating if the load was successful.
-   */
-  ET_NODISCARD virtual Error load_into(size_t offset, size_t size,
-                                       const SegmentInfo &segment_info,
-                                       void *buffer) const {
-    // Using a stub implementation here instead of pure virtual to expand the
-    // data_loader interface in a backwards compatible way.
-    (void)buffer;
-    (void)offset;
-    (void)size;
-    (void)segment_info;
-    ET_LOG(Error, "load_into() not implemented for this data loader.");
-    return Error::NotImplemented;
-  }
-
-  /**
-   * Returns the length of the underlying data source, typically the file size.
-   */
-  ET_NODISCARD virtual Result<size_t> size() const = 0;
-};
-
-} // 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::DataLoader;
-} // namespace executor
-} // namespace torch

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

@@ -1,20 +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.
- */
-
-/**
- * @file
- * Contains preprocessor definitions used by ExecuTorch core.
- */
-
-#pragma once
-
-// Enable ET_ENABLE_ENUM_STRINGS by default. This option gates inclusion of
-// enum string names and can be disabled by explicitly setting it to 0.
-#ifndef ET_ENABLE_ENUM_STRINGS
-#define ET_ENABLE_ENUM_STRINGS 1
-#endif