react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

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

@@ -0,0 +1,90 @@
+/*
+ * 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>
+
+// X11 headers via volk define None, so we need to undef it
+#if defined(__linux__)
+#undef None
+#endif
+
+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
+};
+
+#if ET_ENABLE_ENUM_STRINGS
+inline const char *tag_to_string(Tag tag) {
+  switch (tag) {
+#define CASE_TAG(x)                                                            \
+  case Tag::x:                                                                 \
+    return #x;
+    EXECUTORCH_FORALL_TAGS(CASE_TAG)
+#undef CASE_TAG
+  default:
+    return "Unknown";
+  }
+}
+#endif // ET_ENABLE_ENUM_STRINGS
+
+/**
+ * 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/include/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 ET_RUNTIME_NAMESPACE {
+
+/**
+ * Describes the layout of a tensor.
+ */
+class 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 ET_RUNTIME_NAMESPACE
+} // namespace executorch

package/third-party/include/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/include/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

package/third-party/include/executorch/runtime/executor/merged_data_map.h

@@ -0,0 +1,142 @@
+/*
+ * 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/named_data_map.h>
+
+namespace executorch {
+namespace ET_RUNTIME_NAMESPACE {
+namespace internal {
+
+/**
+ * A NamedDataMap implementation that wraps other NamedDataMaps.
+ */
+class MergedDataMap final : public NamedDataMap {
+public:
+  /**
+   * Creates a new NamedDataMap that wraps two other data maps.
+   *
+   * @param[in] first The first NamedDataMap to merge.
+   * @param[in] second The second NamedDataMap to merge.
+   * Note: the data maps must outlive the MergedDataMap instance.
+   */
+  static Result<MergedDataMap> load(const NamedDataMap *first,
+                                    const NamedDataMap *second) {
+    ET_CHECK_OR_RETURN_ERROR(first != nullptr && second != nullptr,
+                             InvalidArgument, "Input data map is null.");
+
+    // Check for duplicate keys.
+    for (uint32_t k = 0; k < first->get_num_keys().get(); k++) {
+      const auto key = first->get_key(k).get();
+      const auto error = second->get_tensor_layout(key).error();
+      // TODO(lfq): add API to check if key exists.
+      ET_CHECK_OR_RETURN_ERROR(error == Error::NotFound ||
+                                   error == Error::NotImplemented,
+                               InvalidArgument, "Duplicate key %s.", key);
+    }
+    return MergedDataMap(first, second);
+  }
+
+  /**
+   * Retrieve the tensor_layout for the specified key.
+   *
+   * @param[in] key The name of the tensor to get metadata on.
+   *
+   * @return Error::NotFound if the key is not present.
+   */
+  ET_NODISCARD
+  Result<const TensorLayout>
+  get_tensor_layout(executorch::aten::string_view key) const override {
+    auto layout = first_->get_tensor_layout(key);
+    if (layout.ok()) {
+      return layout.get();
+    }
+    if (layout.error() != Error::NotFound) {
+      return layout.error();
+    }
+    return second_->get_tensor_layout(key);
+  }
+
+  /**
+   * Retrieve read-only data for the specified key.
+   *
+   * @param[in] key The name of the tensor to get data on.
+   *
+   * @return error if the key is not present or data cannot be loaded.
+   */
+  ET_NODISCARD
+  Result<FreeableBuffer>
+  get_data(executorch::aten::string_view key) const override {
+    auto data = first_->get_data(key);
+    if (data.error() != Error::NotFound) {
+      return data;
+    }
+    return second_->get_data(key);
+  }
+
+  /**
+   * Loads the data of the specified tensor into the provided buffer.
+   * Not used in the MergedDataMap.
+   *
+   * @param[in] key The name of the tensor to get the data of.
+   * @param[in] buffer The buffer to load data into. Must point to at least
+   * `size` bytes of memory.
+   * @param[in] size The number of bytes to load.
+   *
+   * @returns an Error indicating if the load was successful.
+   */
+  ET_NODISCARD Error load_data_into(ET_UNUSED executorch::aten::string_view key,
+                                    ET_UNUSED void *buffer,
+                                    ET_UNUSED size_t size) const override {
+    return Error::NotImplemented;
+  }
+
+  /**
+   * @returns The number of keys in the map.
+   */
+  ET_NODISCARD Result<uint32_t> get_num_keys() const override {
+    return first_->get_num_keys().get() + second_->get_num_keys().get();
+  }
+
+  /**
+   * @returns The key at the specified index, error if index out of bounds.
+   */
+  ET_NODISCARD Result<const char *> get_key(uint32_t index) const override {
+    uint32_t total_num_keys = get_num_keys().get();
+    ET_CHECK_OR_RETURN_ERROR(index < total_num_keys, InvalidArgument,
+                             "Index %" PRIu32 " out of range of size %" PRIu32,
+                             index, total_num_keys);
+
+    if (index < first_->get_num_keys().get()) {
+      return first_->get_key(index);
+    } else {
+      return second_->get_key(index - first_->get_num_keys().get());
+    }
+  }
+
+  MergedDataMap(MergedDataMap &&) noexcept = default;
+
+  ~MergedDataMap() override = default;
+
+private:
+  MergedDataMap(const NamedDataMap *first, const NamedDataMap *second)
+      : first_{first}, second_{second} {}
+
+  // Not copyable or assignable.
+  MergedDataMap(const MergedDataMap &rhs) = delete;
+  MergedDataMap &operator=(MergedDataMap &&rhs) noexcept = delete;
+  MergedDataMap &operator=(const MergedDataMap &rhs) = delete;
+
+  const NamedDataMap *first_;
+  const NamedDataMap *second_;
+};
+
+} // namespace internal
+} // namespace ET_RUNTIME_NAMESPACE
+} // namespace executorch