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

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

@@ -0,0 +1,258 @@
+/*
+ * 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
+ * Result type to be used in conjunction with ExecuTorch Error type.
+ */
+
+#pragma once
+
+#include <new>
+#include <utility>
+
+#include "executorch/runtime/core/error.h"
+#include "executorch/runtime/platform/assert.h"
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Result type wrapping either a value of type T or an error.
+ *
+ * Example use case:
+ * @code
+ *   Result<OpFn> getOp(int opcode) {
+ *     if (isValidOpCode(opcode)) {
+ *       return opFns[opcode];
+ *     }
+ *     return Error::NotFound;
+ *   }
+ *
+ *   Error useOp(int opcode) {
+ *     Result<OpFn> op = getOp(opcode);
+ *     if (!op.ok()) {
+ *       return op.error();
+ *     }
+ *     print(op->toString());
+ *     execute(*op);
+ *     return Error::Ok;
+ *   }
+ * @endcode
+ */
+template <typename T> class Result final {
+public:
+  /// `value_type` member for generic programming.
+  typedef T value_type;
+
+  /**
+   * Creates a Result object from an Error.
+   *
+   * To preserve the invariant that `(result.error() == Error::Ok) ==
+   * result.ok()`, an `error` parameter value of `Error:Ok` will be converted to
+   * a non-Ok value.
+   */
+  /* implicit */ Result(Error error)
+      : error_(error == Error::Ok ? Error::Internal : error), hasValue_(false) {
+    if ET_UNLIKELY (error == Error::Ok) {
+      ET_LOG(Debug, "Attempted to create Result from Error::Ok, this has been "
+                    "converted to Error::Internal.");
+    }
+  }
+
+  /// Value copy constructor.
+  /* implicit */ Result(const T &val) : value_(val), hasValue_(true) {}
+
+  /// Value move constructor.
+  /* implicit */ Result(T &&val) : value_(std::move(val)), hasValue_(true) {}
+
+  /// Result move constructor.
+  /* implicit */ Result(Result &&rhs) noexcept : hasValue_(rhs.hasValue_) {
+    if (hasValue_) {
+      // Use the value type's move constructor.
+      new (&value_) T(std::move(rhs.value_));
+    } else {
+      error_ = rhs.error_;
+    }
+  }
+
+  ~Result() {
+    if (hasValue_) {
+      // Manual value destruction.
+      // Result "owns" the memory, so `delete` would segfault.
+      value_.~T();
+    }
+  }
+
+  /**
+   * Returns true if this Result has a value.
+   *
+   * If true, it is guaranteed that `error()` will return `Error::Ok`.
+   * If false, it is guaranteed that `error()` will not return `Error::Ok`.
+   */
+  ET_NODISCARD bool ok() const { return hasValue_; }
+
+  /**
+   * Returns the error code of this Result.
+   *
+   * If this returns `Error::Ok`, it is guaranteed that `ok()` will return true.
+   * If this does not return `Error:Ok`, it is guaranteed that `ok()` will
+   * return false.
+   */
+  ET_NODISCARD Error error() const {
+    if (hasValue_) {
+      return Error::Ok;
+    } else {
+      return error_;
+    }
+  }
+
+  /**
+   * Returns a reference to the Result's value; longhand for operator*().
+   *
+   * Only legal to call if `ok()` returns true.
+   */
+  T &get() {
+    CheckOk();
+    return value_;
+  }
+
+  /**
+   * Returns a reference to the Result's value; longhand for operator*().
+   *
+   * Only legal to call if `ok()` returns true.
+   */
+  const T &get() const {
+    CheckOk();
+    return value_;
+  }
+
+  /*
+   * Returns a reference to the Result's value; shorthand for get().
+   *
+   * Only legal to call if `ok()` returns true.
+   */
+  const T &operator*() const &;
+  T &operator*() &;
+
+  /*
+   * Returns a pointer to the Result's value.
+   *
+   * Only legal to call if `ok()` returns true.
+   */
+  const T *operator->() const;
+  T *operator->();
+
+private:
+  /**
+   * Delete default constructor since all Results should contain a value or
+   * error.
+   */
+  Result() = delete;
+  /// Delete copy constructor since T may not be copyable.
+  Result(const Result &) = delete;
+  /// Delete copy assignment since T may not be copyable.
+  Result &operator=(const Result &) = delete;
+  /// Delete move assignment since it's not a supported pattern to reuse Result.
+  Result &operator=(Result &&rhs) = delete;
+
+  // Panics if ok() would return false;
+  void CheckOk() const { ET_CHECK(hasValue_); }
+
+  union {
+    T value_;     // Used if hasValue_ is true.
+    Error error_; // Used if hasValue_ is false.
+  };
+
+  /// True if the Result contains a value.
+  const bool hasValue_;
+};
+
+template <typename T> const T &Result<T>::operator*() const & {
+  CheckOk();
+  return value_;
+}
+
+template <typename T> T &Result<T>::operator*() & {
+  CheckOk();
+  return value_;
+}
+
+template <typename T> const T *Result<T>::operator->() const {
+  CheckOk();
+  return &value_;
+}
+
+template <typename T> T *Result<T>::operator->() {
+  CheckOk();
+  return &value_;
+}
+
+} // 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::Result;
+} // namespace executor
+} // namespace torch
+
+/**
+ * Unwrap a Result to obtain its value. If the Result contains an error,
+ * propogate the error via trivial function return.
+ *
+ * Note: A function using ET_UNWRAP should itself return a Result or Error.
+ *
+ * @param[in] result__ Expression yielding the result to unwrap.
+ * @param[in] ... Optional format string for the log error message and its
+ * arguments.
+ */
+#define ET_UNWRAP(result__, ...) ET_INTERNAL_UNWRAP(result__, ##__VA_ARGS__)
+
+// Internal only: Use ET_UNWRAP() instead.
+#define ET_INTERNAL_UNWRAP(...)                                                \
+  ET_INTERNAL_UNWRAP_SELECT(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)        \
+  (__VA_ARGS__)
+
+// Internal only: Use ET_UNWRAP() instead.
+#define ET_INTERNAL_UNWRAP_SELECT(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N,  \
+                                  ...)                                         \
+  ET_INTERNAL_UNWRAP_##N
+
+// Internal only: Use ET_UNWRAP() instead.
+#define ET_INTERNAL_UNWRAP_1(result__)                                         \
+  ({                                                                           \
+    auto et_result__ = (result__);                                             \
+    if (!et_result__.ok()) {                                                   \
+      return et_result__.error();                                              \
+    }                                                                          \
+    std::move(*et_result__);                                                   \
+  })
+
+// Internal only: Use ET_UNWRAP() instead.
+#define ET_INTERNAL_UNWRAP_2(result__, message__, ...)                         \
+  ({                                                                           \
+    auto et_result__ = (result__);                                             \
+    if (!et_result__.ok()) {                                                   \
+      ET_LOG(Error, message__, ##__VA_ARGS__);                                 \
+      return et_result__.error();                                              \
+    }                                                                          \
+    std::move(*et_result__);                                                   \
+  })
+
+// Internal only: Use ET_UNWRAP() instead.
+#define ET_INTERNAL_UNWRAP_3 ET_INTERNAL_UNWRAP_2
+#define ET_INTERNAL_UNWRAP_4 ET_INTERNAL_UNWRAP_2
+#define ET_INTERNAL_UNWRAP_5 ET_INTERNAL_UNWRAP_2
+#define ET_INTERNAL_UNWRAP_6 ET_INTERNAL_UNWRAP_2
+#define ET_INTERNAL_UNWRAP_7 ET_INTERNAL_UNWRAP_2
+#define ET_INTERNAL_UNWRAP_8 ET_INTERNAL_UNWRAP_2
+#define ET_INTERNAL_UNWRAP_9 ET_INTERNAL_UNWRAP_2
+#define ET_INTERNAL_UNWRAP_10 ET_INTERNAL_UNWRAP_2

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

@@ -0,0 +1,93 @@
+/*
+ * 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 <cstdint>
+
+#include <executorch/runtime/platform/assert.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Represent a 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 Span.
+ *
+ * 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 Span final {
+public:
+  using value_type = T;
+  using iterator = T *;
+  using size_type = size_t;
+
+public:
+  /// Construct an empty Span.
+  /* implicit */ constexpr Span() noexcept : data_(nullptr), length_(0) {}
+
+  /// Construct a Span from a pointer and length.
+  Span(T *data, size_t length) : data_(data), length_(length) {
+    ET_DCHECK(data_ != nullptr || length_ == 0);
+  }
+
+  /// Construct a Span from a range.
+  Span(T *begin, T *end) : data_(begin), length_(end - begin) {}
+
+  /// Construct a Span from a C array.
+  template <size_t N>
+  /* implicit */ constexpr Span(T (&Arr)[N]) : data_(Arr), length_(N) {}
+
+  /// @returns a pointer to the start of the underlying element buffer.
+  iterator begin() const noexcept { return data_; }
+
+  /// @returns a pointer to the end of the underlying element buffer.
+  iterator end() const noexcept { return data_ + length_; }
+
+  /// @retval a boolean indicating if the Span is empty.
+  constexpr bool empty() const noexcept { return length_ == 0; }
+
+  /// @returns a pointer to the start of the underlying element buffer.
+  constexpr T *data() const noexcept { return data_; }
+
+  /// @returns the number of elements in the Span.
+  constexpr size_t size() const noexcept { return length_; }
+
+  /// Unchecked index into the array according to the argument index.
+  /// @returns a reference to the element at the specified index.
+  T &operator[](size_t index) const { return data_[index]; }
+
+private:
+  /// The start of the array, in an external buffer.
+  T *data_;
+
+  /// The number of elements.
+  size_type length_;
+};
+
+} // 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::Span;
+} // namespace executor
+} // namespace torch

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64-simulator/Headers/executorch/runtime/core/tag.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 <cstdint>
+#include <executorch/runtime/core/defines.h>
+#include <executorch/runtime/platform/compiler.h>
+
+namespace executorch {
+namespace runtime {
+
+#define EXECUTORCH_FORALL_TAGS(_)                                              \
+  _(None)                                                                      \
+  _(Tensor)                                                                    \
+  _(String)                                                                    \
+  _(Double)                                                                    \
+  _(Int)                                                                       \
+  _(Bool)                                                                      \
+  _(ListBool)                                                                  \
+  _(ListDouble)                                                                \
+  _(ListInt)                                                                   \
+  _(ListTensor)                                                                \
+  _(ListScalar)                                                                \
+  _(ListOptionalTensor)
+
+/**
+ * The dynamic type of an EValue.
+ */
+enum class Tag : uint32_t {
+#define DEFINE_TAG(x) x,
+  EXECUTORCH_FORALL_TAGS(DEFINE_TAG)
+#undef DEFINE_TAG
+};
+
+/**
+ * Convert a tag value to a string representation. If ET_ENABLE_ENUM_STRINGS is
+ * set (it is on by default), this will return a string name (for example,
+ * "Tensor"). Otherwise, it will return a string representation of the index
+ * value ("1").
+ *
+ * If the user buffer is not large enough to hold the string representation, the
+ * string will be truncated.
+ *
+ * The return value is the number of characters written, or in the case of
+ * truncation, the number of characters that would be written if the buffer was
+ * large enough.
+ */
+size_t tag_to_string(Tag tag, char *buffer, size_t buffer_size);
+
+/* The size of the buffer needed to hold the longest tag string, including the
+ * null terminator. This value is expected to be updated manually, but it
+ * checked in test_tag.cpp.
+ */
+constexpr size_t kTagNameBufferSize = 19;
+
+} // 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::Tag;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,79 @@
+/*
+ * 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/exec_aten/exec_aten.h>
+#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
+#include <executorch/runtime/core/result.h>
+#include <executorch/runtime/core/span.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Describes the layout of a tensor.
+ */
+class ET_EXPERIMENTAL TensorLayout final {
+public:
+  TensorLayout() = delete;
+
+  /**
+   * Creates a TensorLayout from the given parameters.
+   *
+   * @param[in] sizes The sizes of the tensor. Note: the span passed here must
+   * outlive the TensorLayout and all copies of it.
+   * @param[in] dim_order The dim order of the tensor. Note: the span passed
+   * here must outlive the TensorLayout and all copies of it.
+   * @param[in] scalar_type The scalar type of the tensor.
+   * @return A Result containing the TensorLayout on success, or an error.
+   */
+  static executorch::runtime::Result<const TensorLayout>
+  create(Span<const int32_t> sizes, Span<const uint8_t> dim_order,
+         executorch::aten::ScalarType scalar_type);
+
+  /**
+   * Returns the sizes of the tensor.
+   *
+   * NOTE: The TensorLayout must outlive the spans returned here.
+   */
+  Span<const int32_t> sizes() const { return sizes_; }
+
+  /**
+   * Returns the dim order of the tensor.
+   *
+   * NOTE: The TensorLayout must outlive the spans returned here.
+   */
+  Span<const uint8_t> dim_order() const { return dim_order_; }
+
+  /// Returns the scalar type of the tensor.
+  executorch::aten::ScalarType scalar_type() const { return scalar_type_; }
+
+  /// Returns the size of the tensor in bytes.
+  size_t nbytes() const { return nbytes_; }
+
+private:
+  TensorLayout(Span<const int32_t> sizes, Span<const uint8_t> dim_order,
+               executorch::aten::ScalarType scalar_type, size_t nbytes)
+      : sizes_(sizes), dim_order_(dim_order), scalar_type_(scalar_type),
+        nbytes_(nbytes) {}
+  /// The sizes of the tensor.
+  const Span<const int32_t> sizes_;
+
+  /// The dim order of the tensor.
+  const Span<const uint8_t> dim_order_;
+
+  /// The scalar type of the tensor.
+  const executorch::aten::ScalarType scalar_type_;
+
+  /// The size in bytes of the tensor.
+  const size_t nbytes_;
+};
+
+} // namespace runtime
+} // namespace executorch

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

@@ -0,0 +1,39 @@
+/*
+ * 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 <cstdint>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * The resizing capabilities of a Tensor.
+ *
+ * The rank of an ExecuTorch Tensors can never change, but shape sometimes can.
+ */
+enum class TensorShapeDynamism : uint8_t {
+  /// Cannot change shape.
+  STATIC = 0,
+  /// Shape cannot exceed initial capacity.
+  DYNAMIC_BOUND = 1,
+  /// No restriction on shape and capacity.
+  DYNAMIC_UNBOUND = 2,
+};
+
+} // 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::TensorShapeDynamism;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,113 @@
+/*
+ * 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/hierarchical_allocator.h>
+#include <executorch/runtime/core/memory_allocator.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * A container class for allocators used during Method load and execution.
+ *
+ * This class consolidates all dynamic memory needs for Method load and
+ * execution. This can allow for heap-based as well as heap-less execution
+ * (relevant to some embedded scenarios), and overall provides more control over
+ * memory use.
+ *
+ * This class, however, cannot ensure all allocation is accounted for since
+ * kernel and backend implementations are free to use a separate way to allocate
+ * memory (e.g., for things like scratch space). But we do suggest that backends
+ * and kernels use these provided allocators whenever possible.
+ */
+class MemoryManager final {
+public:
+  /**
+   * Constructs a new MemoryManager.
+   *
+   * @param[in] method_allocator The allocator to use when loading a Method and
+   *     allocating its internal structures. Must outlive the Method that uses
+   *     it.
+   * @param[in] planned_memory The memory-planned buffers to use for mutable
+   *     tensor data when executing a Method. Must outlive the Method that uses
+   *     it. May be `nullptr` if the Method does not use any memory-planned
+   *     tensor data. The sizes of the buffers in this HierarchicalAllocator
+   *     must agree with the corresponding
+   *     `MethodMeta::num_memory_planned_buffers()` and
+   *     `MethodMeta::memory_planned_buffer_size(N)` values, which are embedded
+   *     in the Program.
+   * @param[in] temp_allocator The allocator to use when allocating temporary
+   *     data during kernel or delegate execution. Must outlive the Method that
+   *     uses it. May be `nullptr` if the Method does not use kernels or
+   *     delegates that allocate temporary data. This allocator will be reset
+   *     after every kernel or delegate call during execution.
+   */
+  explicit MemoryManager(MemoryAllocator *method_allocator,
+                         HierarchicalAllocator *planned_memory = nullptr,
+                         MemoryAllocator *temp_allocator = nullptr)
+      : method_allocator_(method_allocator), planned_memory_(planned_memory),
+        temp_allocator_(temp_allocator) {
+    ET_CHECK_MSG(method_allocator != temp_allocator,
+                 "method allocator cannot be the same as temp allocator");
+  }
+
+  /**
+   * DEPRECATED: Use the constructor without `constant_allocator` instead.
+   *
+   * TODO(T162089316): Remove this once all users migrate to the new ctor.
+   */
+  ET_DEPRECATED MemoryManager(MemoryAllocator *constant_allocator,
+                              HierarchicalAllocator *non_constant_allocator,
+                              MemoryAllocator *runtime_allocator,
+                              MemoryAllocator *temporary_allocator)
+      : MemoryManager(
+            /*method_allocator=*/runtime_allocator,
+            /*planned_memory=*/non_constant_allocator,
+            /*temp_allocator=*/temporary_allocator) {
+    (void)constant_allocator; // Suppress unused variable warning
+  }
+
+  /**
+   * Returns the allocator that the runtime will use to allocate internal
+   * structures while loading a Method. Must not be used after its associated
+   * Method has been loaded.
+   */
+  MemoryAllocator *method_allocator() const { return method_allocator_; }
+
+  /**
+   * Returns the memory-planned buffers to use for mutable tensor data.
+   */
+  HierarchicalAllocator *planned_memory() const { return planned_memory_; }
+
+  /**
+   * Returns the allocator to use for allocating temporary data during kernel or
+   * delegate execution.
+   *
+   * This allocator will be reset after every kernel or delegate call during
+   * execution.
+   */
+  MemoryAllocator *temp_allocator() const { return temp_allocator_; }
+
+private:
+  MemoryAllocator *method_allocator_;
+  HierarchicalAllocator *planned_memory_;
+  MemoryAllocator *temp_allocator_;
+};
+
+} // 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::MemoryManager;
+} // namespace executor
+} // namespace torch