react-native-executorch 0.4.8 → 0.5.0

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

@@ -0,0 +1,107 @@
+/*
+ * 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>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * A read-only buffer than can be freed.
+ */
+class FreeableBuffer final {
+public:
+  // Callback signature for the function that does the freeing.
+  using FreeFn = void (*)(void *context, void *data, size_t size);
+
+  /**
+   * Creates an empty FreeableBuffer with size zero and a null data pointer.
+   */
+  FreeableBuffer()
+      : free_fn_(nullptr), free_fn_context_(nullptr), data_(nullptr), size_(0) {
+  }
+
+  /**
+   * Creates a FreeableBuffer with an optional free function.
+   *
+   * @param[in] data The data of the segment.
+   * @param[in] size The size of the segment data, in bytes.
+   * @param[in] free_fn Optional function to free the data. Guaranteed to be
+   *     called exactly once before the FreeableBuffer is destroyed. May be
+   *     nullptr. NOTE: This function must be thread-safe. If it modifies common
+   *     state, the function must do its own locking.
+   * @param[in] free_fn_context Opaque pointer to pass as the `context`
+   *     parameter of `free_fn`. May be nullptr.
+   */
+  FreeableBuffer(const void *data, size_t size, FreeFn free_fn,
+                 void *free_fn_context = nullptr)
+      : free_fn_(free_fn), free_fn_context_(free_fn_context), data_(data),
+        size_(size) {}
+
+  /**
+   * Move ctor. Takes the ownership of the data previously owned by `rhs`,
+   * leaving `rhs` pointing to nullptr.
+   */
+  FreeableBuffer(FreeableBuffer &&rhs) noexcept
+      : free_fn_(rhs.free_fn_), free_fn_context_(rhs.free_fn_context_),
+        data_(rhs.data_), size_(rhs.size_) {
+    rhs.free_fn_ = nullptr;
+    rhs.free_fn_context_ = nullptr;
+    rhs.data_ = nullptr;
+    rhs.size_ = 0;
+  }
+
+  ~FreeableBuffer() { Free(); }
+
+  /**
+   * Frees the data if not already free. Safe to call multiple times.
+   */
+  void Free() {
+    if (data_ != nullptr) {
+      if (free_fn_ != nullptr) {
+        free_fn_(free_fn_context_, const_cast<void *>(data_), size_);
+      }
+      data_ = nullptr;
+      size_ = 0;
+    }
+  }
+
+  /**
+   * Size of the data in bytes. Returns 0 if the data has been freed.
+   */
+  size_t size() const { return size_; }
+
+  /**
+   * Pointer to the data. Returns nullptr if the data has been freed.
+   */
+  const void *data() const { return data_; }
+
+private:
+  // Delete other rule-of-five methods.
+  FreeableBuffer(const FreeableBuffer &rhs) = delete;
+  FreeableBuffer &operator=(FreeableBuffer &&rhs) noexcept = delete;
+  FreeableBuffer &operator=(const FreeableBuffer &rhs) = delete;
+
+  FreeFn free_fn_;
+  void *free_fn_context_;
+  const void *data_;
+  size_t size_;
+};
+
+} // 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::FreeableBuffer;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,107 @@
+/*
+ * 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 <c10/util/irange.h>
+#include <cstdint>
+#include <executorch/runtime/core/memory_allocator.h>
+#include <executorch/runtime/core/result.h>
+#include <executorch/runtime/core/span.h>
+#include <executorch/runtime/platform/assert.h>
+#include <executorch/runtime/platform/compiler.h>
+#include <executorch/runtime/platform/log.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * A group of buffers that can be used to represent a device's memory hierarchy.
+ */
+class HierarchicalAllocator final {
+public:
+  /**
+   * Constructs a new hierarchical allocator with the given array of buffers.
+   *
+   * - Memory IDs are based on the index into `buffers`: `buffers[N]` will have
+   *   a memory ID of `N`.
+   * - `buffers.size()` must be >= `MethodMeta::num_non_const_buffers()`.
+   * - `buffers[N].size()` must be >= `MethodMeta::non_const_buffer_size(N)`.
+   */
+  explicit HierarchicalAllocator(Span<Span<uint8_t>> buffers)
+      : buffers_(buffers) {}
+
+  /**
+   * DEPRECATED: Use spans instead.
+   */
+  ET_DEPRECATED HierarchicalAllocator(uint32_t n_allocators,
+                                      MemoryAllocator *allocators)
+      : buffers_(to_spans(n_allocators, allocators)) {}
+
+  /**
+   * Returns the address at the byte offset `offset_bytes` from the given
+   * buffer's base address, which points to at least `size_bytes` of memory.
+   *
+   * @param[in] memory_id The ID of the buffer in the hierarchy.
+   * @param[in] offset_bytes The offset in bytes into the specified buffer.
+   * @param[in] size_bytes The amount of memory that should be available at
+   *     the offset.
+   *
+   * @returns On success, the address of the requested byte offset into the
+   *     specified buffer. On failure, a non-Ok Error.
+   */
+  ET_NODISCARD Result<void *> get_offset_address(uint32_t memory_id,
+                                                 size_t offset_bytes,
+                                                 size_t size_bytes) {
+    ET_CHECK_OR_RETURN_ERROR(memory_id < buffers_.size(), InvalidArgument,
+                             "id %" PRIu32 " >= %" ET_PRIsize_t, memory_id,
+                             buffers_.size());
+    Span<uint8_t> buffer = buffers_[memory_id];
+    ET_CHECK_OR_RETURN_ERROR(
+        offset_bytes + size_bytes <= buffer.size(), MemoryAllocationFailed,
+        "offset_bytes (%" ET_PRIsize_t ") + size_bytes (%" ET_PRIsize_t
+        ") >= allocator size (%" ET_PRIsize_t ") "
+        "for memory_id %" PRIu32,
+        offset_bytes, size_bytes, buffer.size(), memory_id);
+    return buffer.data() + offset_bytes;
+  }
+
+private:
+  // TODO(T162089316): Remove the span array and to_spans once all users move to
+  // spans. This array is necessary to hold the pointers and sizes that were
+  // originally provided as MemoryAllocator instances.
+  static constexpr size_t kSpanArraySize = 16;
+  // NOTE: span_array_ must be declared before buffers_ so that it isn't
+  // re-initialized to zeros after initializing buffers_.
+  Span<uint8_t> span_array_[kSpanArraySize];
+  Span<Span<uint8_t>> to_spans(uint32_t n_allocators,
+                               MemoryAllocator *allocators) {
+    ET_CHECK_MSG(n_allocators <= kSpanArraySize,
+                 "n_allocators %" PRIu32 " > %zu", n_allocators,
+                 kSpanArraySize);
+    for (const auto i : c10::irange(n_allocators)) {
+      span_array_[i] =
+          Span<uint8_t>(allocators[i].base_address(), allocators[i].size());
+    }
+    return {span_array_, n_allocators};
+  }
+
+  /// The underlying buffers.
+  Span<Span<uint8_t>> buffers_;
+};
+
+} // 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::HierarchicalAllocator;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,198 @@
+/*
+ * 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 <cinttypes>
+#include <cstdint>
+#include <stdio.h>
+
+#include <executorch/runtime/core/error.h>
+#include <executorch/runtime/platform/assert.h>
+#include <executorch/runtime/platform/compiler.h>
+#include <executorch/runtime/platform/log.h>
+#include <executorch/runtime/platform/profiler.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * A class that does simple allocation based on a size and returns the pointer
+ * to the memory address. It bookmarks a buffer with certain size. The
+ * allocation is simply checking space and growing the cur_ pointer with each
+ * allocation request.
+ *
+ * Simple example:
+ *
+ *   // User allocates a 100 byte long memory in the heap.
+ *   uint8_t* memory_pool = malloc(100 * sizeof(uint8_t));
+ *   MemoryAllocator allocator(100, memory_pool)
+ *   // Pass allocator object in the Executor
+ *
+ *   Underneath the hood, ExecuTorch will call
+ *   allocator.allocate() to keep iterating cur_ pointer
+ */
+class MemoryAllocator {
+public:
+  /**
+   * Default alignment of memory returned by this class. Ensures that pointer
+   * fields of structs will be aligned. Larger types like `long double` may not
+   * be, however, depending on the toolchain and architecture.
+   */
+  static constexpr size_t kDefaultAlignment = alignof(void *);
+
+  /**
+   * Constructs a new memory allocator of a given `size`, starting at the
+   * provided `base_address`.
+   *
+   * @param[in] size The size in bytes of the buffer at `base_address`.
+   * @param[in] base_address The buffer to allocate from. Does not take
+   *     ownership of this buffer, so it must be valid for the lifetime of of
+   *     the MemoryAllocator.
+   */
+  MemoryAllocator(uint32_t size, uint8_t *base_address)
+      : begin_(base_address), end_(base_address + size), cur_(base_address),
+        size_(size) {}
+
+  /**
+   * Allocates `size` bytes of memory.
+   *
+   * @param[in] size Number of bytes to allocate.
+   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
+   *     power of 2.
+   *
+   * @returns Aligned pointer to the allocated memory on success.
+   * @retval nullptr Not enough memory, or `alignment` was not a power of 2.
+   */
+  virtual void *allocate(size_t size, size_t alignment = kDefaultAlignment) {
+    if (!isPowerOf2(alignment)) {
+      ET_LOG(Error, "Alignment %zu is not a power of 2", alignment);
+      return nullptr;
+    }
+
+    // The allocation will occupy [start, end), where the start is the next
+    // position that's a multiple of alignment.
+    uint8_t *start = alignPointer(cur_, alignment);
+    uint8_t *end = start + size;
+
+    // If the end of this allocation exceeds the end of this allocator, print
+    // error messages and return nullptr
+    if (end > end_) {
+      ET_LOG(Error,
+             "Memory allocation failed: %zuB requested (adjusted for "
+             "alignment), %zuB available",
+             static_cast<size_t>(end - cur_), static_cast<size_t>(end_ - cur_));
+      return nullptr;
+    }
+
+    // Otherwise, record how many bytes were used, advance cur_ to the new end,
+    // and then return start. Note that the number of bytes used is (end - cur_)
+    // instead of (end - start) because start > cur_ if there is a misalignment
+    EXECUTORCH_TRACK_ALLOCATION(prof_id_, end - cur_);
+    cur_ = end;
+    return static_cast<void *>(start);
+  }
+
+  /**
+   * Allocates a buffer large enough for an instance of type T. Note that the
+   * memory will not be initialized.
+   *
+   * Example:
+   * @code
+   *   auto p = memory_allocator->allocateInstance<MyType>();
+   * @endcode
+   *
+   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
+   *     power of 2. Defaults to the natural alignment of T.
+   *
+   * @returns Aligned pointer to the allocated memory on success.
+   * @retval nullptr Not enough memory, or `alignment` was not a power of 2.
+   */
+  template <typename T> T *allocateInstance(size_t alignment = alignof(T)) {
+    return static_cast<T *>(this->allocate(sizeof(T), alignment));
+  }
+
+  /**
+   * Allocates `size` number of chunks of type T, where each chunk is of size
+   * equal to sizeof(T) bytes.
+   *
+   * @param[in] size Number of memory chunks to allocate.
+   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
+   *     power of 2. Defaults to the natural alignment of T.
+   *
+   * @returns Aligned pointer to the allocated memory on success.
+   * @retval nullptr Not enough memory, or `alignment` was not a power of 2.
+   */
+  template <typename T>
+  T *allocateList(size_t size, size_t alignment = alignof(T)) {
+    // Some users of this method allocate lists of pointers, causing the next
+    // line to expand to `sizeof(type *)`, which triggers a clang-tidy warning.
+    // NOLINTNEXTLINE(bugprone-sizeof-expression)
+    return static_cast<T *>(this->allocate(size * sizeof(T), alignment));
+  }
+
+  // Returns the allocator memory's base address.
+  virtual uint8_t *base_address() const { return begin_; }
+
+  // Returns the total size of the allocator's memory buffer.
+  virtual uint32_t size() const { return size_; }
+
+  // Resets the current pointer to the base address. It does nothing to
+  // the contents.
+  virtual void reset() { cur_ = begin_; }
+
+  void enable_profiling(ET_UNUSED const char *name) {
+    prof_id_ = EXECUTORCH_TRACK_ALLOCATOR(name);
+  }
+
+  virtual ~MemoryAllocator() {}
+
+protected:
+  /**
+   * Returns the profiler ID for this allocator.
+   */
+  int32_t prof_id() const { return prof_id_; }
+
+  /**
+   * Returns true if the value is an integer power of 2.
+   */
+  static bool isPowerOf2(size_t value) {
+    return value > 0 && (value & ~(value - 1)) == value;
+  }
+
+  /**
+   * Returns the next alignment for a given pointer.
+   */
+  static uint8_t *alignPointer(void *ptr, size_t alignment) {
+    intptr_t addr = reinterpret_cast<intptr_t>(ptr);
+    if ((addr & (alignment - 1)) == 0) {
+      // Already aligned.
+      return reinterpret_cast<uint8_t *>(ptr);
+    }
+    addr = (addr | (alignment - 1)) + 1;
+    return reinterpret_cast<uint8_t *>(addr);
+  }
+
+private:
+  uint8_t *const begin_;
+  uint8_t *const end_;
+  uint8_t *cur_;
+  uint32_t const size_;
+  int32_t prof_id_ = -1;
+};
+
+} // 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::MemoryAllocator;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,86 @@
+/*
+ * 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
+
+#ifdef __GNUC__
+// Disable -Wdeprecated-declarations, as some builds use 'Werror'.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/core/freeable_buffer.h>
+#include <executorch/runtime/core/result.h>
+#include <executorch/runtime/core/span.h>
+#include <executorch/runtime/core/tensor_layout.h>
+#include <executorch/runtime/platform/compiler.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Interface to access and retrieve data via name.
+ * See executorch/extension/flat_tensor/ for an example.
+ */
+class ET_EXPERIMENTAL NamedDataMap {
+public:
+  virtual ~NamedDataMap() = default;
+  /**
+   * Get metadata by key.
+   *
+   * @param key The name of the tensor.
+   * @return Result containing TensorLayout with tensor metadata.
+   */
+  ET_NODISCARD virtual Result<const executorch::runtime::TensorLayout>
+  get_metadata(const char *key) const = 0;
+  /**
+   * Get data by key.
+   *
+   * @param key Name of the data.
+   * @return Result containing a FreeableBuffer with the tensor data.
+   */
+  ET_NODISCARD virtual Result<FreeableBuffer>
+  get_data(const char *key) const = 0;
+
+  /**
+   * Loads data corresponding to the key into the provided buffer.
+   *
+   * @param key The name of the data.
+   * @param size The number of bytes to load. Use `get_metadata` to retrieve the
+   * size of the data for a given key.
+   * @param buffer The buffer to load the 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_data_into(const char *key, void *buffer,
+                                            size_t size) const = 0;
+
+  /**
+   * Get the number of keys in the NamedDataMap.
+   *
+   * @return Result containing the number of keys.
+   */
+  ET_NODISCARD virtual Result<size_t> get_num_keys() const = 0;
+
+  /**
+   * Get the key at the given index.
+   *
+   * @param index The index of the key to retrieve.
+   * @return Result containing the key at the given index. Note: the returned
+   * pointer is only valid for the lifetime of the DataMap.
+   */
+  ET_NODISCARD virtual Result<const char *> get_key(size_t index) const = 0;
+};
+
+} // namespace runtime
+} // namespace executorch
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif

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

@@ -0,0 +1,27 @@
+/*
+ * 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 <c10/util/BFloat16.h>
+
+namespace executorch::runtime::etensor {
+using c10::BFloat16;
+namespace internal {
+using c10::detail::f32_from_bits;
+using c10::detail::round_to_nearest_even;
+} // namespace internal
+} // namespace executorch::runtime::etensor
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::runtime::etensor::BFloat16;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,14 @@
+/*
+ * 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/portable_type/bfloat16.h>
+#include <executorch/runtime/core/portable_type/half.h>
+
+#include <c10/util/BFloat16-math.h>

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

@@ -0,0 +1,83 @@
+/*
+ * 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 {
+namespace etensor {
+
+/**
+ * bits1x8 is an uninterpreted dtype of a tensor with 1 bit (packed to byte
+ * boundary), without any semantics defined.
+ */
+struct alignas(1) bits1x8 {
+  using underlying = uint8_t;
+  uint8_t val_;
+  bits1x8() = default;
+  explicit bits1x8(uint8_t val) : val_(val) {}
+};
+
+/**
+ * bits2x4 is an uninterpreted dtype of a tensor with 2 bits (packed to byte
+ * boundary), without any semantics defined.
+ */
+struct alignas(1) bits2x4 {
+  using underlying = uint8_t;
+  uint8_t val_;
+  bits2x4() = default;
+  explicit bits2x4(uint8_t val) : val_(val) {}
+};
+
+/**
+ * bits4x2 is an uninterpreted dtype of a tensor with 4 bits (packed to byte
+ * boundary), without any semantics defined.
+ */
+struct alignas(1) bits4x2 {
+  using underlying = uint8_t;
+  uint8_t val_;
+  bits4x2() = default;
+  explicit bits4x2(uint8_t val) : val_(val) {}
+};
+
+/**
+ * bits8 is an uninterpreted dtype of a tensor with 8 bits, without any
+ * semantics defined.
+ */
+struct alignas(1) bits8 {
+  uint8_t val_;
+  bits8() = default;
+  explicit bits8(uint8_t val) : val_(val) {}
+};
+
+/**
+ * bits16 is an uninterpreted dtype of a tensor with 16 bits, without any
+ * semantics defined.
+ */
+struct alignas(2) bits16 {
+  uint16_t val_;
+  bits16() = default;
+  explicit bits16(uint16_t val) : val_(val) {}
+};
+
+} // namespace etensor
+} // 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::etensor::bits16;
+using ::executorch::runtime::etensor::bits1x8;
+using ::executorch::runtime::etensor::bits2x4;
+using ::executorch::runtime::etensor::bits4x2;
+using ::executorch::runtime::etensor::bits8;
+} // namespace executor
+} // namespace torch