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

package/third-party/include/executorch/runtime/core/portable_type/device.h

@@ -0,0 +1,70 @@
+/*
+ * 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/assert.h>
+
+namespace executorch {
+namespace runtime {
+namespace etensor {
+
+/// Denotes the specific genre of compute device.
+/// Subset of https://github.com/pytorch/pytorch/blob/main/c10/core/Device.h
+enum class DeviceType : int8_t {
+  CPU = 0,
+};
+
+/// An index representing a specific device; For cpu it should always be -1 or 0
+using DeviceIndex = int8_t;
+
+/**
+ * An abstraction for the compute device on which a tensor is located.
+ * ExecuTorch doesn't allow dynamic dispatching based on device, so this type is
+ * just a skeleton to allow certain kernels that expect device as an
+ * argument to still be run.
+ *
+ * In ExecuTorch this is always expected to be CPU.
+ */
+struct Device final {
+  using Type = DeviceType;
+
+  /// Constructs a new `Device` from a `DeviceType` and an optional device
+  /// index.
+  /* implicit */ Device(DeviceType type, DeviceIndex index = -1)
+      : type_(type), index_(index) {}
+
+  /// Returns the type of device this is. Only CPU is supported.
+  DeviceType type() const noexcept { return type_; }
+
+  /// Returns true if the device is of CPU type.
+  bool is_cpu() const noexcept { return type_ == DeviceType::CPU; }
+
+  /// Returns the device index. Always 0 if specified or -1 if not provided.
+  DeviceIndex index() const noexcept {
+    ET_CHECK(index_ == 0 || index_ == -1);
+    return index_;
+  }
+
+private:
+  DeviceType type_;
+  DeviceIndex index_ = -1;
+};
+
+} // 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::Device;
+using ::executorch::runtime::etensor::DeviceType;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/core/portable_type/half.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/Half.h>
+
+namespace executorch::runtime::etensor {
+using c10::Half;
+namespace internal {
+using c10::detail::fp16_ieee_from_fp32_value;
+using c10::detail::fp16_ieee_to_fp32_bits;
+using c10::detail::fp16_ieee_to_fp32_value;
+using c10::detail::fp32_from_bits;
+using c10::detail::fp32_to_bits;
+} // namespace internal
+} // namespace executorch::runtime::etensor
+namespace torch::executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::runtime::etensor::Half;
+} // namespace torch::executor

package/third-party/include/executorch/runtime/core/portable_type/optional.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.
+ */
+
+#pragma once
+
+#include <optional>
+
+namespace executorch {
+namespace runtime {
+namespace etensor {
+
+// NOLINTNEXTLINE(misc-unused-using-decls)
+using std::nullopt;
+// NOLINTNEXTLINE(misc-unused-using-decls)
+using std::nullopt_t;
+// NOLINTNEXTLINE(misc-unused-using-decls)
+using std::optional;
+
+} // 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::nullopt;
+using ::executorch::runtime::etensor::nullopt_t;
+using ::executorch::runtime::etensor::optional;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/core/portable_type/qint_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 {
+
+/**
+ * qint8 is for signed 8 bit quantized Tensors
+ */
+struct alignas(1) qint8 {
+  using underlying = int8_t;
+  int8_t val_;
+  qint8() = default;
+  explicit qint8(int8_t val) : val_(val) {}
+};
+
+/**
+ * quint8 is for unsigned 8 bit quantized Tensors
+ */
+struct alignas(1) quint8 {
+  using underlying = uint8_t;
+  uint8_t val_;
+  quint8() = default;
+  explicit quint8(uint8_t val) : val_(val) {}
+};
+
+/**
+ * qint32 is for signed 32 bit quantized Tensors
+ */
+struct alignas(4) qint32 {
+  using underlying = int32_t;
+  int32_t val_;
+  qint32() = default;
+  explicit qint32(int32_t val) : val_(val) {}
+};
+
+/**
+ * quint4x2 is for un-signed 4 bit quantized Tensors that are packed to byte
+ * boundary.
+ */
+struct alignas(1) quint4x2 {
+  using underlying = uint8_t;
+  uint8_t val_;
+  quint4x2() = default;
+  explicit quint4x2(uint8_t val) : val_(val) {}
+};
+
+/**
+ * quint2x4 is for un-signed 2 bit quantized Tensors that are packed to byte
+ * boundary.
+ */
+struct alignas(1) quint2x4 {
+  using underlying = uint8_t;
+  uint8_t val_;
+  quint2x4() = default;
+  explicit quint2x4(uint8_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::qint32;
+using ::executorch::runtime::etensor::qint8;
+using ::executorch::runtime::etensor::quint2x4;
+using ::executorch::runtime::etensor::quint4x2;
+using ::executorch::runtime::etensor::quint8;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/core/portable_type/scalar.h

@@ -0,0 +1,110 @@
+/*
+ * 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 <executorch/runtime/core/tag.h>
+#include <executorch/runtime/platform/assert.h>
+
+#include <cstdint>
+#include <type_traits>
+
+namespace executorch {
+namespace runtime {
+namespace etensor {
+
+/**
+ * Represents a scalar value.
+ *
+ * The API is a source-compatible subset of c10::Scalar, and the
+ * semantics/behavior should also match the c10 version.
+ */
+class Scalar {
+public:
+  Scalar() : Scalar(int64_t(0)) {}
+
+  template <typename T, typename std::enable_if<std::is_integral<T>::value,
+                                                bool>::type = true>
+  /*implicit*/ Scalar(T val) : tag(Tag::Int) {
+    v.as_int = static_cast<int64_t>(val);
+  }
+  /*implicit*/ Scalar(bool val) : tag(Tag::Bool) { v.as_bool = val; }
+  /*implicit*/ Scalar(double val) : tag(Tag::Double) { v.as_double = val; }
+  /*implicit*/ Scalar(BFloat16 val) : Scalar((double)(float)val) {}
+  /*implicit*/ Scalar(Half val) : Scalar((double)(float)val) {}
+
+  /// Returns the concrete scalar value stored within.
+  template <typename T> T to() const;
+
+  /// Returns true if the scalar is integral, false otherwise.
+  bool isIntegral(bool includeBool) const {
+    return Tag::Int == tag || (includeBool && isBoolean());
+  }
+
+  /// Returns true if the scalar is a floating point, false otherwise.
+  bool isFloatingPoint() const { return tag == Tag::Double; }
+
+  /// Returns true if the scalar is a boolean, false otherwise.
+  bool isBoolean() const { return tag == Tag::Bool; }
+
+private:
+  int64_t toInt() const {
+    if (isIntegral(/*includeBool=*/false)) {
+      return v.as_int;
+    } else if (isBoolean()) {
+      return static_cast<int64_t>(v.as_bool);
+    } else {
+      ET_CHECK_MSG(false, "Scalar is not an int nor a Boolean.");
+    }
+  }
+
+  double toFloatingPoint() const {
+    ET_CHECK_MSG(isFloatingPoint(), "Scalar is not a Double.");
+    return v.as_double;
+  }
+
+  double toDouble() const {
+    ET_CHECK_MSG(isFloatingPoint(), "Scalar is not a Double.");
+    return v.as_double;
+  }
+
+  bool toBool() const {
+    ET_CHECK_MSG(isBoolean(), "Scalar is not a Boolean.");
+    return v.as_bool;
+  }
+
+  Tag tag;
+  union v_t {
+    double as_double;
+    int64_t as_int;
+    bool as_bool;
+    v_t() {} // default constructor
+  } v;
+};
+
+#define ET_DEFINE_SCALAR_TO_METHOD(T, name)                                    \
+  template <> inline T Scalar::to<T>() const { return to##name(); }
+
+ET_DEFINE_SCALAR_TO_METHOD(double, Double)
+ET_DEFINE_SCALAR_TO_METHOD(int64_t, Int)
+ET_DEFINE_SCALAR_TO_METHOD(bool, Bool)
+#undef ET_DEFINE_SCALAR_TO_METHOD
+
+} // 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::Scalar;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/core/portable_type/scalar_type.h

@@ -0,0 +1,154 @@
+/*
+ * 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
+ *
+ * Forked from
+ * https://github.com/pytorch/pytorch/blob/master/c10/core/ScalarType.h
+ *
+ * Everything but the ScalarType definition is in util/ScalarTypeUtil.h
+ *
+ * Note that these files do not need to be strictly identical to the pytorch
+ * core file, as far as names go. The only critical piece is that the types and
+ * indices of the main ScalarType enum line up, so that serialization is
+ * compatible between the two.
+ *
+ * Modifications for ExecuTorch:
+ * - Namespace torch::executor instead of c10
+ * - Macro prefix ET_ instead of AT_
+ * - Use ET_CHECK_MSG() instead of TORCH_CHECK()
+ * - Don't define standalone constants like `kByte`, `kInt` to keep the
+ *   namespace clean
+ * - Remove operator<< to avoid a dependency on ostream and stdlib
+ * - Make `static inline` functions `inline` to avoid creating multiple
+ *   copies of them. See
+ *   https://gist.github.com/htfy96/50308afc11678d2e3766a36aa60d5f75#conclusion.
+ * - Remove deprecated definitions
+ * - Minor cleanup for internal consistency
+ */
+
+#pragma once
+
+#include <cstdint>
+
+#include <executorch/runtime/core/portable_type/bfloat16.h>
+#include <executorch/runtime/core/portable_type/bits_types.h>
+#include <executorch/runtime/core/portable_type/complex.h>
+#include <executorch/runtime/core/portable_type/half.h>
+#include <executorch/runtime/core/portable_type/qint_types.h>
+
+namespace executorch {
+namespace runtime {
+namespace etensor {
+
+// Placing a bunch of unused dtypes here as our macros don't make it easy
+// to skip scalar types defined in aten that we dont have.
+namespace unused_dtype {
+struct alignas(1) Float8_e5m2 {
+  uint8_t x;
+  using underlying = uint8_t;
+  Float8_e5m2() = default;
+  explicit Float8_e5m2(uint8_t val) : x(val) {}
+};
+struct alignas(1) Float8_e4m3fn {
+  uint8_t x;
+  using underlying = uint8_t;
+  Float8_e4m3fn() = default;
+  explicit Float8_e4m3fn(uint8_t val) : x(val) {}
+};
+struct alignas(1) Float8_e5m2fnuz {
+  uint8_t x;
+  using underlying = uint8_t;
+  Float8_e5m2fnuz() = default;
+  explicit Float8_e5m2fnuz(uint8_t val) : x(val) {}
+};
+struct alignas(1) Float8_e4m3fnuz {
+  uint8_t x;
+  using underlying = uint8_t;
+  Float8_e4m3fnuz() = default;
+  explicit Float8_e4m3fnuz(uint8_t val) : x(val) {}
+};
+
+} // namespace unused_dtype
+
+/**
+ * Calls the provided macro on every ScalarType, providing the C type and the
+ * ScalarType name to each call.
+ *
+ * The indices and C types must be consistent with
+ * AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS in the core pytorch file
+ * c10/core/ScalarType.h. This ensures that ExecuTorch serialization is
+ * compatible with ATen serialization.
+ *
+ * @param _ A macro that takes two parameters: the name of a C type, and the
+ *     name of the corresponding ScalarType enumerator.
+ */
+#define ET_FORALL_SCALAR_TYPES(_)                                              \
+  _(uint8_t, Byte)                              /* 0 */                        \
+  _(int8_t, Char)                               /* 1 */                        \
+  _(int16_t, Short)                             /* 2 */                        \
+  _(int32_t, Int)                               /* 3 */                        \
+  _(int64_t, Long)                              /* 4 */                        \
+  _(::executorch::runtime::etensor::Half, Half) /* 5 */                        \
+  _(float, Float)                               /* 6 */                        \
+  _(double, Double)                             /* 7 */                        \
+  _(::executorch::runtime::etensor::complex<::torch::executor::Half>,          \
+    ComplexHalf)                                                    /* 8 */    \
+  _(::executorch::runtime::etensor::complex<float>, ComplexFloat)   /* 9 */    \
+  _(::executorch::runtime::etensor::complex<double>, ComplexDouble) /* 10 */   \
+  _(bool, Bool)                                                     /* 11 */   \
+  _(::executorch::runtime::etensor::qint8, QInt8)                   /* 12 */   \
+  _(::executorch::runtime::etensor::quint8, QUInt8)                 /* 13 */   \
+  _(::executorch::runtime::etensor::qint32, QInt32)                 /* 14 */   \
+  _(::executorch::runtime::etensor::BFloat16, BFloat16)             /* 15 */   \
+  _(::executorch::runtime::etensor::quint4x2, QUInt4x2)             /* 16 */   \
+  _(::executorch::runtime::etensor::quint2x4, QUInt2x4)             /* 17 */   \
+  _(::executorch::runtime::etensor::bits1x8, Bits1x8)               /* 18 */   \
+  _(::executorch::runtime::etensor::bits2x4, Bits2x4)               /* 19 */   \
+  _(::executorch::runtime::etensor::bits4x2, Bits4x2)               /* 20 */   \
+  _(::executorch::runtime::etensor::bits8, Bits8)                   /* 21 */   \
+  _(::executorch::runtime::etensor::bits16, Bits16)                 /* 22 */   \
+  _(::executorch::runtime::etensor::unused_dtype::Float8_e5m2,                 \
+    Float8_e5m2) /* 23 */                                                      \
+  _(::executorch::runtime::etensor::unused_dtype::Float8_e4m3fn,               \
+    Float8_e4m3fn) /* 24 */                                                    \
+  _(::executorch::runtime::etensor::unused_dtype::Float8_e5m2fnuz,             \
+    Float8_e5m2fnuz) /* 25 */                                                  \
+  _(::executorch::runtime::etensor::unused_dtype::Float8_e4m3fnuz,             \
+    Float8_e4m3fnuz)  /* 26 */                                                 \
+  _(uint16_t, UInt16) /* 27 */                                                 \
+  _(uint32_t, UInt32) /* 28 */                                                 \
+  _(uint64_t, UInt64) /* 29 */
+
+/**
+ * Data types (dtypes) that can be used as element types in ETensors.
+ */
+enum class ScalarType : int8_t {
+/// Define an enumerator for each ScalarType.
+#define DEFINE_ENUM(unused, name) name,
+  ET_FORALL_SCALAR_TYPES(DEFINE_ENUM)
+#undef DEFINE_ENUM
+
+  /// An explicitly undefined ScalarType. Does not map to any C type.
+  Undefined,
+  /// The number of ScalarType enumerators.
+  NumOptions,
+};
+
+} // 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::ScalarType;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/core/portable_type/string_view.h

@@ -0,0 +1,29 @@
+/*
+ * 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 <string_view>
+
+namespace executorch {
+namespace runtime {
+namespace etensor {
+
+using std::string_view;
+
+} // 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::string_view;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/core/portable_type/tensor.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/platform/compiler.h>
+
+#include <executorch/runtime/core/portable_type/tensor_impl.h>
+
+namespace executorch {
+namespace runtime {
+namespace etensor {
+
+/**
+ * A minimal Tensor type whose API is a source compatible subset of at::Tensor.
+ *
+ * NOTE: Instances of this class do not own the TensorImpl given to it,
+ * which means that the caller must guarantee that the TensorImpl lives longer
+ * than any Tensor instances that point to it.
+ *
+ * See the documention on TensorImpl for details about the return/parameter
+ * types used here and how they relate to at::Tensor.
+ */
+class Tensor {
+public:
+  /// The type used for elements of `sizes()`.
+  using SizesType = TensorImpl::SizesType;
+  /// The type used for elements of `dim_order()`.
+  using DimOrderType = TensorImpl::DimOrderType;
+  /// The type used for elements of `strides()`.
+  using StridesType = TensorImpl::StridesType;
+
+  Tensor() = delete;
+  explicit constexpr Tensor(TensorImpl *impl) : impl_(impl) {}
+
+  /**
+   * Returns a pointer to the underlying TensorImpl.
+   *
+   * NOTE: Clients should be wary of operating on the TensorImpl
+   * directly instead of the Tensor. It is easy to break things.
+   */
+  TensorImpl *unsafeGetTensorImpl() const {
+    // TODO(T154114015): See if we can make this api private with friends.
+    return impl_;
+  }
+
+  /**
+   * Returns the size of the tensor in bytes.
+   *
+   * NOTE: Only the alive space is returned not the total capacity of the
+   * underlying data blob.
+   */
+  size_t nbytes() const { return impl_->nbytes(); }
+
+  /**
+   * Returns the size of the tensor at the given dimension.
+   *
+   * NOTE: that size() intentionally does not return SizeType even though it
+   * returns an element of an array of SizeType. This is to help make calls of
+   * this method more compatible with at::Tensor, and more consistent with the
+   * rest of the methods on this class and in ETensor.
+   */
+  ssize_t size(ssize_t dim) const { return impl_->size(dim); }
+
+  /// Returns the tensor's number of dimensions.
+  ssize_t dim() const { return impl_->dim(); }
+
+  /// Returns the number of elements in the tensor.
+  ssize_t numel() const { return impl_->numel(); }
+
+  /// Returns the type of the elements in the tensor (int32, float, bool, etc).
+  ScalarType scalar_type() const { return impl_->scalar_type(); }
+
+  inline ScalarType dtype() const { return scalar_type(); }
+
+  /// Returns the size in bytes of one element of the tensor.
+  ssize_t element_size() const { return impl_->element_size(); }
+
+  /// Returns the sizes of the tensor at each dimension.
+  const ArrayRef<SizesType> sizes() const { return impl_->sizes(); }
+
+  /// Returns the order the dimensions are laid out in memory.
+  const ArrayRef<DimOrderType> dim_order() const { return impl_->dim_order(); }
+
+  /// Returns the strides of the tensor at each dimension.
+  const ArrayRef<StridesType> strides() const { return impl_->strides(); }
+
+  /// Returns the mutability of the shape of the tensor.
+  TensorShapeDynamism shape_dynamism() const { return impl_->shape_dynamism(); }
+
+  /// Returns a pointer of type T to the constant underlying data blob.
+  template <typename T> inline const T *const_data_ptr() const {
+    return impl_->data<T>();
+  }
+
+  /// Returns a pointer to the constant underlying data blob.
+  inline const void *const_data_ptr() const { return impl_->data(); }
+
+  /// Returns a pointer of type T to the mutable underlying data blob.
+  template <typename T> inline T *mutable_data_ptr() const {
+    return impl_->mutable_data<T>();
+  }
+
+  /// Returns a pointer to the mutable underlying data blob.
+  inline void *mutable_data_ptr() const { return impl_->mutable_data(); }
+
+  /// DEPRECATED: Use const_data_ptr or mutable_data_ptr instead.
+  template <typename T> ET_DEPRECATED inline T *data_ptr() const {
+    return impl_->mutable_data<T>();
+  }
+
+  /// DEPRECATED: Use const_data_ptr or mutable_data_ptr instead.
+  ET_DEPRECATED inline void *data_ptr() const { return impl_->mutable_data(); }
+
+  /**
+   * DEPRECATED: Changes the data_ptr the tensor aliases. Does not free the
+   * previously pointed to data, does not assume ownership semantics of the new
+   * ptr. This api does not exist in at::Tensor so kernel developers should
+   * avoid it.
+   */
+  ET_DEPRECATED void set_data(void *ptr) const { impl_->set_data(ptr); }
+
+private:
+  TensorImpl *impl_ = nullptr;
+};
+
+} // 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::Tensor;
+} // namespace executor
+} // namespace torch