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

package/third-party/include/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/include/executorch/runtime/core/function_ref.h

@@ -0,0 +1,100 @@
+/*
+ * 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.
+ */
+
+//===- llvm/ADT/STLFunctionalExtras.h - Extras for <functional> -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains some extension to <functional>.
+//
+// No library is required when using these functions.
+//
+//===----------------------------------------------------------------------===//
+//     Extra additions to <functional>
+//===----------------------------------------------------------------------===//
+
+/// An efficient, type-erasing, non-owning reference to a callable. This is
+/// intended for use as the type of a function parameter that is not used
+/// after the function in question returns.
+///
+/// This class does not own the callable, so it is not in general safe to store
+/// a FunctionRef.
+
+// torch::executor: modified from llvm::function_ref
+// - renamed to FunctionRef
+// - removed LLVM_GSL_POINTER and LLVM_LIFETIME_BOUND macro uses
+// - use namespaced internal::remove_cvref_t
+
+#pragma once
+
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+namespace executorch::runtime {
+
+//===----------------------------------------------------------------------===//
+//     Features from C++20
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+template <typename T> struct remove_cvref {
+  using type =
+      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+};
+
+template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
+
+} // namespace internal
+
+template <typename Fn> class FunctionRef;
+
+template <typename Ret, typename... Params> class FunctionRef<Ret(Params...)> {
+  Ret (*callback)(intptr_t callable, Params... params) = nullptr;
+  intptr_t callable;
+
+  template <typename Callable>
+  static Ret callback_fn(intptr_t callable, Params... params) {
+    return (*reinterpret_cast<Callable *>(callable))(
+        std::forward<Params>(params)...);
+  }
+
+public:
+  FunctionRef() = default;
+  FunctionRef(std::nullptr_t) {}
+
+  template <typename Callable>
+  FunctionRef(
+      Callable &&callable,
+      // This is not the copy-constructor.
+      std::enable_if_t<!std::is_same<internal::remove_cvref_t<Callable>,
+                                     FunctionRef>::value> * = nullptr,
+      // Functor must be callable and return a suitable type.
+      std::enable_if_t<std::is_void<Ret>::value ||
+                       std::is_convertible<decltype(std::declval<Callable>()(
+                                               std::declval<Params>()...)),
+                                           Ret>::value> * = nullptr)
+      : callback(callback_fn<std::remove_reference_t<Callable>>),
+        callable(reinterpret_cast<intptr_t>(&callable)) {}
+
+  Ret operator()(Params... params) const {
+    return callback(callable, std::forward<Params>(params)...);
+  }
+
+  explicit operator bool() const { return callback; }
+
+  bool operator==(const FunctionRef<Ret(Params...)> &Other) const {
+    return callable == Other.callable;
+  }
+};
+} // namespace executorch::runtime

package/third-party/include/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/include/executorch/runtime/core/memory_allocator.h

@@ -0,0 +1,208 @@
+/*
+ * 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 <c10/util/safe_numerics.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_ || end < start) {
+      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)
+    size_t bytes_size = 0;
+    bool overflow = c10::mul_overflows(size, sizeof(T), &bytes_size);
+    if (overflow) {
+      ET_LOG(Error,
+             "Failed to allocate list of type %zu: size * sizeof(T) overflowed",
+             size);
+      return nullptr;
+    }
+    return static_cast<T *>(this->allocate(bytes_size, 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/include/executorch/runtime/core/named_data_map.h

@@ -0,0 +1,76 @@
+/*
+ * 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/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 ET_RUNTIME_NAMESPACE {
+/**
+ * Interface to access and retrieve data via name.
+ * See executorch/extension/flat_tensor/ for an example.
+ */
+class NamedDataMap {
+public:
+  virtual ~NamedDataMap() = default;
+  /**
+   * Get tensor_layout by key.
+   *
+   * @param key The name of the tensor.
+   * @return Result containing TensorLayout.
+   */
+  ET_NODISCARD virtual Result<const TensorLayout>
+  get_tensor_layout(executorch::aten::string_view key) const = 0;
+  /**
+   * Get data by key.
+   *
+   * @param key Name of the data.
+   * @return Result containing a FreeableBuffer.
+   */
+  ET_NODISCARD virtual Result<FreeableBuffer>
+  get_data(executorch::aten::string_view 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_tensor_layout` 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(executorch::aten::string_view 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<uint32_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(uint32_t index) const = 0;
+};
+
+} // namespace ET_RUNTIME_NAMESPACE
+} // namespace executorch

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