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

package/third-party/include/executorch/runtime/kernel/kernel_runtime_context.h

@@ -0,0 +1,122 @@
+/*
+ * 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/error.h>
+#include <executorch/runtime/core/event_tracer_hooks.h>
+#include <executorch/runtime/core/memory_allocator.h>
+#include <executorch/runtime/core/result.h>
+#include <executorch/runtime/platform/compiler.h>
+
+namespace executorch {
+namespace ET_RUNTIME_NAMESPACE {
+
+/**
+ * Runtime state and functionality for kernel implementations.
+ *
+ * NOTE: Will not be passed to operators if running in ATen mode as those
+ * operators do not expect to receive a KernelRuntimeContext argument.
+ */
+class KernelRuntimeContext {
+public:
+  /**
+   * Construct a new kernel runtime context.
+   *
+   * KernelRuntimeContext does not take ownership
+   * of these pointers, so they must outlive the context instance.
+   *
+   * @param[in] event_tracer The optional EventTracer to use for
+   *     profiling/debugging
+   * @param[in] temp_allocator The optional MemoryAllocator used to allocate
+   *     temporary memory for the kernel. If not provided, an error will be
+   *     returned when calling allocate_temp.
+   */
+  KernelRuntimeContext(EventTracer *event_tracer = nullptr,
+                       MemoryAllocator *temp_allocator = nullptr)
+      : event_tracer_(event_tracer), temp_allocator_(temp_allocator) {}
+  /**
+   * Tells the runtime that the kernel call has failed. Prefer this over
+   * ET_CHECK_*(), which fatally panics the process/system.
+   *
+   * If this is not called, the runtime will treat the kernel call as
+   * successful.
+   *
+   * This unusual error-propagation path is required because kernel signatures
+   * do not have a natural way to return errors directly. They are generally
+   * compatible with core PyTorch ATen kernel signatures, which use exceptions
+   * to report errors. But, ExecuTorch does not use exceptions.
+   */
+  void fail(Error error) { failure_state_ = error; }
+
+  /// Returns the current failure state.
+  ET_NODISCARD Error failure_state() const { return failure_state_; }
+
+  /**
+   * INTERNAL ONLY
+   *
+   * Returns a pointer to an instance of EventTracer to do profiling/debugging
+   * logging inside the codegen layer. This is only for internal usage inside
+   * the codegen layer and users should not be accessing this.
+   */
+  EventTracer *internal_event_tracer() { return event_tracer_; }
+
+  /**
+   * Allocates temporary memory that will be freed when the kernel returns. This
+   * returns a pointer to the allocated memory or an error if the allocation
+   * fails.
+   *
+   * @param[in] size Number of bytes to allocate.
+   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
+   *     power of 2.
+   *
+   * @returns A result object containing either a pointer to the allocated
+   *     memory or an error to indicate failure
+   */
+  Result<void *>
+  allocate_temp(size_t size,
+                size_t alignment = MemoryAllocator::kDefaultAlignment) {
+    ET_CHECK_OR_RETURN_ERROR(temp_allocator_ != nullptr, NotFound,
+                             "No temp allocator provided");
+    void *temp_memory = temp_allocator_->allocate(size, alignment);
+    ET_CHECK_OR_RETURN_ERROR(
+        temp_memory != nullptr, MemoryAllocationFailed,
+        "Failed to allocate temp memory. Bytes requested: %zu", size);
+    return temp_memory;
+  }
+
+  // TODO(T147221312): Add a way to resize a tensor.
+
+private:
+  EventTracer *event_tracer_ = nullptr;
+  MemoryAllocator *temp_allocator_ = nullptr;
+  Error failure_state_ = Error::Ok;
+};
+
+} // namespace ET_RUNTIME_NAMESPACE
+} // namespace executorch
+
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+namespace torch {
+namespace executor {
+/// DEPRECATED: Use ::executorch::runtime::KernelRuntimeContext instead.
+using ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
+/// DEPRECATED: Use ::executorch::runtime::KernelRuntimeContext instead.
+using RuntimeContext = ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
+} // namespace executor
+} // namespace torch
+namespace executorch {
+namespace aten {
+/// DEPRECATED: Use ::executorch::runtime::KernelRuntimeContext instead.
+using RuntimeContext = ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
+} // namespace aten
+} // namespace executorch
+// DEPRECATED: The executorch::aten:: namespace is deprecated. Use
+// executorch::aten:: instead.
+namespace exec_aten = ::executorch::aten;

package/third-party/include/executorch/runtime/kernel/operator_registry.h

@@ -0,0 +1,280 @@
+/*
+ * 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/core/array_ref.h>
+#include <executorch/runtime/core/error.h>
+#include <executorch/runtime/core/evalue.h>
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/core/result.h>
+#include <executorch/runtime/core/span.h>
+#include <executorch/runtime/platform/compiler.h>
+#include <executorch/runtime/platform/platform.h>
+
+// Debug switch for operator registry
+#if defined(ET_OP_REGISTRY_DEBUG)
+#include <ostream>
+#endif
+
+#define ET_LOG_KERNEL_KEY(k)                                                   \
+  ET_LOG(Info, "key: %s, is_fallback: %s", k.data(),                           \
+         k.is_fallback() ? "true" : "false");
+#define ET_LOG_TENSOR_META(meta_list)                                          \
+  for (const auto &meta : meta_list) {                                         \
+    ET_LOG(Info, "dtype: %d | dim order: [", int(meta.dtype_));                \
+    for (size_t i = 0; i < meta.dim_order_.size(); i++) {                      \
+      ET_LOG(Info, "%d,", static_cast<int32_t>(meta.dim_order_[i]));           \
+    }                                                                          \
+    ET_LOG(Info, "]");                                                         \
+  }
+
+namespace executorch {
+namespace ET_RUNTIME_NAMESPACE {
+
+class KernelRuntimeContext; // Forward declaration
+using OpFunction = void (*)(KernelRuntimeContext &, Span<EValue *>);
+
+/**
+ * Dtype and dim order metadata for a Tensor argument to an operator.
+ * Used by the Executor to hold the tensor metadata info and retrieve kernel.
+ */
+struct TensorMeta {
+  executorch::aten::ScalarType dtype_;
+  Span<executorch::aten::DimOrderType> dim_order_;
+
+  TensorMeta() = default;
+  TensorMeta(executorch::aten::ScalarType dtype,
+             Span<executorch::aten::DimOrderType> order)
+      : dtype_(dtype), dim_order_(order) {}
+
+  bool operator==(const TensorMeta &other) const { return this->equals(other); }
+
+  bool operator!=(const TensorMeta &other) const {
+    return !this->equals(other);
+  }
+
+  bool equals(const TensorMeta &other) const {
+    if (dtype_ != other.dtype_) {
+      return false;
+    }
+    if (dim_order_.size() != other.dim_order_.size()) {
+      return false;
+    }
+    for (size_t i = 0; i < dim_order_.size(); i++) {
+      if (dim_order_[i] != other.dim_order_[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+#if defined(ET_OP_REGISTRY_DEBUG)
+  friend std::ostream &operator<<(std::ostream &os, const TensorMeta &meta) {
+    os << "dtype: " << int(meta.dtype_) << " | dim order: [";
+    for (int i = 0; i < meta.dim_order_.size(); i++) {
+      os << static_cast<int32_t>(meta.dim_order_[i]) << ", ";
+    }
+    os << "]";
+    return os;
+  }
+#endif
+};
+
+/**
+ * Describes which dtype & dim order specialized kernel to be bound to an
+ * operator.
+ *
+ * Kernel key data is a string with the format:
+ *
+ *     "v<version>/<tensor_meta>|<tensor_meta>..."
+ *
+ * The version is v1 for now. If the kernel key format changes, update the
+ * version to avoid breaking pre-existing kernel keys.
+ *
+ * Each tensor_meta has the following format: "<dtype>;<dim_order,...>"
+ *
+ * Example kernel key data: "v1/7;0,1,2,3|1;0,1,2,3,4,5,6,7"
+ *
+ * This has two tensors: the first with dtype=7 and dim order 0,1,2,3, and the
+ * second with dtype=1 and dim order 0,1,2,3,4,5,6,7.
+ *
+ * IMPORTANT:
+ * Users should not construct a kernel key manually. Instead, it should be
+ * generated from kernel yaml.
+ */
+struct KernelKey {
+public:
+  /**
+   * Creates a fallback (non-specialized) kernel key: this kernel can be used
+   * for all input tensor dtypes and dim orders if the specialized kernel is not
+   * registered.
+   */
+  KernelKey() = default;
+
+  /**
+   * Creates a specialized (non-fallback) kernel key that matches a specific
+   * set of input tensor dtypes and dim orders. See the class comment for the
+   * expected format of `kernel_key_data`.
+   */
+  /* implicit */ KernelKey(const char *kernel_key_data)
+      : kernel_key_data_(kernel_key_data) {}
+
+  bool operator==(const KernelKey &other) const { return this->equals(other); }
+
+  bool operator!=(const KernelKey &other) const { return !this->equals(other); }
+
+  bool equals(const KernelKey &other) const {
+    if (is_fallback() != other.is_fallback()) {
+      return false;
+    }
+    if (is_fallback()) {
+      return true;
+    }
+    return strcmp(kernel_key_data_, other.kernel_key_data_) == 0;
+  }
+
+  bool is_fallback() const { return kernel_key_data_ == nullptr; }
+
+  const char *data() const { return kernel_key_data_; }
+
+#if defined(ET_OP_REGISTRY_DEBUG)
+  friend std::ostream &operator<<(std::ostream &os, const KernelKey &key) {
+    os << key.kernel_key_data_ << std::endl;
+    return os;
+  }
+#endif
+
+private:
+  const char *kernel_key_data_ = nullptr;
+};
+
+/**
+ * Struct that bundles a kernel key, a function and an op name together. An
+ * `Operator` may have more than one `Kernel` (maximum kMaxNumOfKernelPerOp) and
+ * they should have the same op name and different kernel key. A "fallback"
+ * kernel may or may not live in an `Operator`.
+ */
+struct Kernel {
+  const char *name_;
+  // String representation of kernel key, with the same format as
+  // KernelKey.to_string_representation()
+  // Data is not owned by the Kernel struct.
+  KernelKey kernel_key_;
+  OpFunction op_;
+  /**
+   * We are doing a copy of the string pointer instead of duplicating the string
+   * itself, we require the lifetime of the operator name to be at least as long
+   * as the operator registry.
+   */
+  explicit Kernel(const char *name, OpFunction func) : name_(name), op_(func) {}
+
+  explicit Kernel(const char *name, KernelKey key, OpFunction func)
+      : name_(name), kernel_key_(key), op_(func) {}
+
+  Kernel() {}
+};
+
+namespace internal {
+
+/**
+ * A make_kernel_key_string buffer size that is large enough to hold a kernel
+ * key string with 16 tensors of 16 dimensions, plus the trailing NUL byte.
+ */
+constexpr size_t kKernelKeyBufSize = 659;
+
+/**
+ * Given the list of input tensor dtypes + dim orders, writes the kernel key
+ * string into the buffer. Returns an error if the buffer is too small or if the
+ * tensors cannot be represented as a valid key string.
+ */
+Error make_kernel_key_string(Span<const TensorMeta> key, char *buf,
+                             size_t buf_size);
+
+} // namespace internal
+
+/**
+ * Checks whether an operator exists with a given name and TensorMeta list. When
+ * TensorMeta is empty, it means this op does not have specialized kernels, so
+ * it checks whether it has any fallback kernels.
+ */
+bool registry_has_op_function(const char *name,
+                              Span<const TensorMeta> meta_list = {});
+
+/**
+ * Returns the operator with a given name and TensorMeta list, if present.
+ */
+::executorch::runtime::Result<OpFunction>
+get_op_function_from_registry(const char *name,
+                              Span<const TensorMeta> meta_list = {});
+
+/**
+ * Returns all registered kernels.
+ */
+Span<const Kernel> get_registered_kernels();
+
+/**
+ * Registers the provided kernels.
+ *
+ * @param[in] kernels Kernel objects to register.
+ * @retval Error::Ok always. Panics on error. This function needs to return a
+ *     non-void type to run at static initialization time.
+ */
+ET_NODISCARD Error register_kernels(const Span<const Kernel>);
+
+/**
+ * Registers a single kernel.
+ *
+ * @param[in] kernel Kernel object to register.
+ * @retval Error::Ok always. Panics on error. This function needs to return a
+ *     non-void type to run at static initialization time.
+ */
+ET_NODISCARD inline Error register_kernel(const Kernel &kernel) {
+  return register_kernels({&kernel, 1});
+};
+
+} // namespace ET_RUNTIME_NAMESPACE
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::ET_RUNTIME_NAMESPACE::Kernel;
+using ::executorch::ET_RUNTIME_NAMESPACE::KernelKey;
+using ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
+using ::executorch::ET_RUNTIME_NAMESPACE::OpFunction;
+using ::executorch::ET_RUNTIME_NAMESPACE::TensorMeta;
+using KernelRuntimeContext =
+    ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
+
+inline ::executorch::runtime::Error register_kernels(ArrayRef<Kernel> kernels) {
+  return ::executorch::ET_RUNTIME_NAMESPACE::register_kernels(
+      {kernels.data(), kernels.size()});
+}
+inline OpFunction getOpsFn(const char *name,
+                           ArrayRef<TensorMeta> meta_list = {}) {
+  auto result =
+      ::executorch::ET_RUNTIME_NAMESPACE::get_op_function_from_registry(
+          name, {meta_list.data(), meta_list.size()});
+  ET_CHECK(result.ok()); // get_op_function_from_registry() logs details.
+  return *result;
+}
+inline bool hasOpsFn(const char *name, ArrayRef<TensorMeta> meta_list = {}) {
+  return ::executorch::ET_RUNTIME_NAMESPACE::registry_has_op_function(
+      name, {meta_list.data(), meta_list.size()});
+}
+inline ArrayRef<Kernel> get_kernels() {
+  Span<const Kernel> kernels =
+      ::executorch::ET_RUNTIME_NAMESPACE::get_registered_kernels();
+  return ArrayRef<Kernel>(kernels.data(), kernels.size());
+}
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/platform/abort.h

@@ -0,0 +1,36 @@
+/*
+ * 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
+ * ExecuTorch global abort wrapper function.
+ */
+
+#pragma once
+
+#include <executorch/runtime/platform/compiler.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Trigger the ExecuTorch global runtime to immediately exit without cleaning
+ * up, and set an abnormal exit status (platform-defined).
+ */
+ET_NORETURN void runtime_abort();
+
+} // 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::runtime_abort;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/platform/assert.h

@@ -0,0 +1,119 @@
+/*
+ * 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/platform/abort.h>
+#include <executorch/runtime/platform/compiler.h>
+#include <executorch/runtime/platform/log.h>
+
+/**
+ * Assertion failure message emit method.
+ *
+ * @param[in] _format Printf-style message format string.
+ * @param[in] ... Format string arguments.
+ */
+#define ET_ASSERT_MESSAGE_EMIT(_format, ...)                                   \
+  ET_LOG(Fatal, "In function %s(), assert failed" _format, ET_FUNCTION,        \
+         ##__VA_ARGS__)
+
+/**
+ * Abort the runtime if the condition is not true.
+ * This check will be performed even in release builds.
+ *
+ * @param[in] _cond Condition asserted as true.
+ * @param[in] _format Printf-style message format string.
+ * @param[in] ... Format string arguments.
+ */
+#define ET_CHECK_MSG(_cond, _format, ...)                                      \
+  do {                                                                         \
+    if ET_UNLIKELY (!(_cond)) {                                                \
+      ET_ASSERT_MESSAGE_EMIT(" (%s): " _format, #_cond, ##__VA_ARGS__);        \
+      ::executorch::runtime::runtime_abort();                                  \
+    }                                                                          \
+  } while (0)
+
+/**
+ * Abort the runtime if the condition is not true.
+ * This check will be performed even in release builds.
+ *
+ * @param[in] _cond Condition asserted as true.
+ */
+#define ET_CHECK(_cond)                                                        \
+  do {                                                                         \
+    if ET_UNLIKELY (!(_cond)) {                                                \
+      ET_ASSERT_MESSAGE_EMIT(": %s", #_cond);                                  \
+      ::executorch::runtime::runtime_abort();                                  \
+    }                                                                          \
+  } while (0)
+
+#ifdef NDEBUG
+
+/**
+ * Abort the runtime if the condition is not true.
+ * This check will be performed in debug builds, but not release builds.
+ *
+ * @param[in] _cond Condition asserted as true.
+ * @param[in] _format Printf-style message format string.
+ * @param[in] ... Format string arguments.
+ */
+#define ET_DCHECK_MSG(_cond, _format, ...) ((void)0)
+
+/**
+ * Abort the runtime if the condition is not true.
+ * This check will be performed in debug builds, but not release builds.
+ *
+ * @param[in] _cond Condition asserted as true.
+ */
+#define ET_DCHECK(_cond) ((void)0)
+#define ET_DEBUG_ONLY [[maybe_unused]]
+
+#else // NDEBUG
+
+/**
+ * Abort the runtime if the condition is not true.
+ * This check will be performed in debug builds, but not release builds.
+ *
+ * @param[in] _cond Condition asserted as true.
+ * @param[in] _format Printf-style message format string.
+ * @param[in] ... Format string arguments.
+ */
+#define ET_DCHECK_MSG(_cond, _format, ...)                                     \
+  ET_CHECK_MSG(_cond, _format, ##__VA_ARGS__)
+
+/**
+ * Abort the runtime if the condition is not true.
+ * This check will be performed in debug builds, but not release builds.
+ *
+ * @param[in] _cond Condition asserted as true.
+ */
+#define ET_DCHECK(_cond) ET_CHECK(_cond)
+#define ET_DEBUG_ONLY
+
+#endif // NDEBUG
+
+/**
+ * Assert that this code location is unreachable during execution.
+ */
+#define ET_ASSERT_UNREACHABLE()                                                \
+  do {                                                                         \
+    ET_CHECK_MSG(false, "Execution should not reach this point");              \
+    ET_UNREACHABLE();                                                          \
+  } while (0)
+
+/**
+ * Assert that this code location is unreachable during execution.
+ *
+ * @param[in] _message Message on how to avoid this assertion error.
+ */
+#define ET_ASSERT_UNREACHABLE_MSG(_format, ...)                                \
+  do {                                                                         \
+    ET_CHECK_MSG(false, "Execution should not reach this point. " _format,     \
+                 ##__VA_ARGS__);                                               \
+    ET_UNREACHABLE();                                                          \
+  } while (0)

package/third-party/include/executorch/runtime/platform/clock.h

@@ -0,0 +1,43 @@
+/*
+ * 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
+ * Clock and timing related methods.
+ */
+
+#pragma once
+
+#include <executorch/runtime/platform/platform.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Convert an interval from units of system ticks to nanoseconds.
+ * The conversion ratio is platform-dependent, and thus depends on
+ * the platform implementation of et_pal_ticks_to_ns_multiplier().
+ *
+ * @param[in] ticks The interval length in system ticks.
+ * @retval The interval length in nanoseconds.
+ */
+inline uint64_t ticks_to_ns(et_timestamp_t ticks) {
+  et_tick_ratio_t ratio = et_pal_ticks_to_ns_multiplier();
+  return static_cast<uint64_t>(ticks) * ratio.numerator / ratio.denominator;
+}
+
+} // 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::ticks_to_ns;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/platform/compat_unistd.h

@@ -0,0 +1,75 @@
+/*
+ * 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
+ * unistd.h related macros for POSIX/Windows compatibility.
+ */
+#pragma once
+
+#if defined(_WIN32) && !defined(_WIN64)
+#error                                                                         \
+    "You're trying to build ExecuTorch with a too old version of Windows. We need Windows 64-bit."
+#endif
+
+#if !defined(_WIN64)
+#include <unistd.h>
+#else
+#include <io.h>
+#define O_RDONLY _O_RDONLY
+#define open _open
+#define close _close
+#define read _read
+#define write _write
+#define stat _stat64
+#define fstat _fstat64
+#define off_t _off_t
+#define lseek _lseeki64
+
+#include <executorch/runtime/platform/compiler.h> // For ssize_t.
+#include <windows.h>
+// To avoid conflicts with std::numeric_limits<int32_t>::max() in
+// file_data_loader.cpp.
+#undef max
+
+inline ssize_t pread(int fd, void *buf, size_t nbytes, size_t offset) {
+  OVERLAPPED overlapped; /* The offset for ReadFile. */
+  memset(&overlapped, 0, sizeof(overlapped));
+  overlapped.Offset = offset;
+  overlapped.OffsetHigh = offset >> 32;
+
+  BOOL result;      /* The result of ReadFile. */
+  DWORD bytes_read; /* The number of bytes read. */
+  HANDLE file = (HANDLE)_get_osfhandle(fd);
+
+  result = ReadFile(file, buf, nbytes, &bytes_read, &overlapped);
+  DWORD error = GetLastError();
+  if (!result) {
+    if (error == ERROR_IO_PENDING) {
+      result = GetOverlappedResult(file, &overlapped, &bytes_read, TRUE);
+      if (!result) {
+        error = GetLastError();
+      }
+    }
+  }
+  if (!result) {
+    // Translate error into errno.
+    switch (error) {
+    case ERROR_HANDLE_EOF:
+      errno = 0;
+      break;
+    default:
+      errno = EIO;
+      break;
+    }
+    return -1;
+  }
+  return bytes_read;
+}
+
+#endif // !defined(_WIN64)