react-native-executorch 0.4.8 → 0.5.0

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

@@ -0,0 +1,71 @@
+/*
+ * 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/Headers/executorch/runtime/backend/backend_init_context.h

@@ -0,0 +1,72 @@
+/*
+ * 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/Headers/executorch/runtime/backend/interface.h

@@ -0,0 +1,166 @@
+/*
+ * 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/Headers/executorch/runtime/core/array_ref.h

@@ -0,0 +1,235 @@
+/*
+ * 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/Headers/executorch/runtime/core/data_loader.h

@@ -0,0 +1,136 @@
+/*
+ * 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/Headers/executorch/runtime/core/defines.h

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