react-native-executorch 0.5.2 → 0.5.3

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/extension/tensor/tensor.h

@@ -1,13 +0,0 @@
-/*
- * 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
-
-// Umbrella header for the Tensor extension.
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <executorch/extension/tensor/tensor_ptr_maker.h>

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/extension/tensor/tensor_accessor.h

@@ -1,190 +0,0 @@
-/*
- * 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/result.h>
-
-namespace executorch {
-namespace extension {
-namespace internal {
-
-/**
- * Base class template storing the underlying data with size and stride helpers.
- * Inherited by TensorAccessor<> which requires specialization on rank.
- */
-template <typename T, ssize_t N> class TensorAccessorBase {
-public:
-  /// Returns the size of the underlying tensor at the given dimension.
-  executorch::aten::SizesType size(ssize_t i) const {
-    ET_CHECK_MSG(i < dim_ && i >= 0, "Dimension outside of [0, %zd], got %zd",
-                 dim_ - 1, i);
-    return sizes_[i];
-  }
-
-  /// Returns the stride of the underlying tensor at the given dimension.
-  executorch::aten::StridesType stride(ssize_t i) const {
-    ET_CHECK_MSG(i < dim_ && i >= 0, "Dimension outside of [0, %zd], got %zd",
-                 dim_ - 1, i);
-    return strides_[i];
-  }
-
-protected:
-  TensorAccessorBase(T *data, const executorch::aten::SizesType *sizes,
-                     const executorch::aten::StridesType *strides, ssize_t dim)
-      : data_(data), sizes_(sizes), strides_(strides), dim_(dim) {}
-
-  T *data_;
-  const executorch::aten::SizesType *sizes_;
-  const executorch::aten::StridesType *strides_;
-  ssize_t dim_;
-};
-
-} // namespace internal
-
-/**
- * TensorAccessor template with data type and rank as template parameters. No
- * public constructors, can only be created using make_tensor_accessor from a
- * given executorch::aten::Tensor. Use operator[] to index and obtain a lower
- * rank accessor or the underlying scalar value.
- */
-template <typename T, ssize_t N>
-class TensorAccessor : public internal::TensorAccessorBase<T, N> {
-public:
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return If N > 1, a TensorAccessor with N-1 dimensions. If N == 1, a
-   * reference to the underlying scalar. Refer to the TensorAccessor<T, 1>
-   * specialization.
-   */
-  TensorAccessor<T, N - 1> operator[](ssize_t i) {
-    return TensorAccessor<T, N - 1>(this->data_ + this->strides_[0] * i,
-                                    this->sizes_ + 1, this->strides_ + 1,
-                                    N - 1);
-  }
-
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return If N > 1, a constant TensorAccessor with N-1 dimensions. If N == 1,
-   * a constant reference to the underlying scalar. Refer to the
-   * TensorAccessor<T, 1> specialization.
-   */
-  const TensorAccessor<T, N - 1> operator[](ssize_t i) const {
-    return TensorAccessor<T, N - 1>(this->data_ + this->strides_[0] * i,
-                                    this->sizes_ + 1, this->strides_ + 1,
-                                    N - 1);
-  }
-
-private:
-  TensorAccessor(T *data, const executorch::aten::SizesType *sizes,
-                 const executorch::aten::StridesType *strides, ssize_t dim)
-      : internal::TensorAccessorBase<T, N>(data, sizes, strides, dim) {}
-
-  template <typename T2, ssize_t N2> friend class TensorAccessor;
-
-  template <typename T2, ssize_t N2>
-  friend executorch::runtime::Result<TensorAccessor<T2, N2>>
-  make_tensor_accessor(const executorch::aten::Tensor &t);
-};
-
-/**
- * TensorAccessor specialization for N == 1, where operator[] returns a
- * reference to the underlying scalar.
- */
-template <typename T>
-class TensorAccessor<T, 1> : public internal::TensorAccessorBase<T, 1> {
-public:
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return Reference to the underlying scalar.
-   */
-  T &operator[](ssize_t i) { return this->data_[this->strides_[0] * i]; }
-
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return Constant reference to the underlying scalar.
-   */
-  const T &operator[](ssize_t i) const {
-    return this->data_[this->strides_[0] * i];
-  }
-
-private:
-  TensorAccessor(T *data, const executorch::aten::SizesType *sizes,
-                 const executorch::aten::StridesType *strides, ssize_t dim)
-      : internal::TensorAccessorBase<T, 1>(data, sizes, strides, dim) {}
-
-  template <typename T2, ssize_t N2> friend class TensorAccessor;
-
-  template <typename T2, ssize_t N2>
-  friend executorch::runtime::Result<TensorAccessor<T2, N2>>
-  make_tensor_accessor(const executorch::aten::Tensor &t);
-};
-
-/**
- * Creates a TensorAccessor<T, N> from the given tensor. The number of dimension
- * N and the data type T's size must match those of the input tensor. For
- * Executorch tensors, non-trivial dimension order is not supported.
- *
- * @param tensor Origin tensor. The TensorImpl inside must outlive the returned
- * TensorAccessor.
- * @return TensorAccessor of the input tensor.
- * @retval Error::InvalidArgument Mismatch on data type or number of dimensions.
- * @retval Error::NotSupported Input tensor has non-trivial dimension onrder.
- */
-template <typename T, ssize_t N>
-executorch::runtime::Result<TensorAccessor<T, N>>
-make_tensor_accessor(const executorch::aten::Tensor &tensor) {
-  static_assert(N > 0, "TensorAccessor is used for indexing tensors, for "
-                       "scalar use *_data_ptr<T>()");
-
-  if (N != tensor.dim()) {
-    ET_LOG(Error, "Expecting %zd dimensions but tensor has %zd.",
-           static_cast<ssize_t>(N), static_cast<ssize_t>(tensor.dim()));
-    return executorch::runtime::Error::InvalidArgument;
-  }
-
-  if (sizeof(T) != tensor.element_size()) {
-    ET_LOG(Error,
-           "Size of data type template argument (%zd) not equal to tensor "
-           "element size (%zd)",
-           static_cast<ssize_t>(sizeof(T)),
-           static_cast<ssize_t>(tensor.element_size()));
-    return executorch::runtime::Error::InvalidArgument;
-  }
-
-#ifndef USE_ATEN_LIB
-  auto dim_order = tensor.dim_order();
-  for (ssize_t i = 0; i < dim_order.size(); i++) {
-    if (dim_order[i] != i) {
-      ET_LOG(Error, "Non-trival dim_order not supported.");
-      return executorch::runtime::Error::NotSupported;
-    }
-  }
-#endif
-
-  T *ptr = nullptr;
-  if constexpr (std::is_const_v<T>) {
-    ptr = tensor.const_data_ptr<T>();
-  } else {
-    ptr = tensor.mutable_data_ptr<T>();
-  }
-  return TensorAccessor<T, N>(ptr, tensor.sizes().data(),
-                              tensor.strides().data(), N);
-}
-
-} // namespace extension
-} // namespace executorch

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/extension/tensor/tensor_ptr.h

@@ -1,347 +0,0 @@
-/*
- * 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 <algorithm>
-#include <functional>
-#include <memory>
-#include <vector>
-
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-
-namespace executorch {
-namespace extension {
-
-/**
- * A smart pointer type for managing the lifecycle of a Tensor.
- */
-using TensorPtr = std::shared_ptr<executorch::aten::Tensor>;
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A pointer to the data buffer.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of the tensor.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @param deleter A custom deleter function for managing the lifetime of the
- * data buffer. If provided, this deleter will be called when the managed Tensor
- * object is destroyed.
- * @return A TensorPtr that manages the newly created Tensor.
- */
-TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes, void *data,
-                std::vector<executorch::aten::DimOrderType> dim_order,
-                std::vector<executorch::aten::StridesType> strides,
-                const executorch::aten::ScalarType type =
-                    executorch::aten::ScalarType::Float,
-                const executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND,
-                std::function<void(void *)> deleter = nullptr);
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A pointer to the data buffer.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @param deleter A custom deleter function for managing the lifetime of the
- * data buffer. If provided, this deleter will be called when the managed Tensor
- * object is destroyed.
- * @return A TensorPtr that manages the newly created Tensor.
- */
-inline TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes, void *data,
-                const executorch::aten::ScalarType type =
-                    executorch::aten::ScalarType::Float,
-                const executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND,
-                std::function<void(void *)> deleter = nullptr) {
-  return make_tensor_ptr(std::move(sizes), data, {}, {}, type, dynamism,
-                         std::move(deleter));
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload is specialized for cases where the tensor data is
- * provided as a vector. The scalar type is automatically deduced from the
- * vector's data type. If the specified `type` differs from the deduced type of
- * the vector's elements, and casting is allowed, the data will be cast to the
- * specified `type`. This allows for flexible creation of tensors with data
- * vectors of one type and a different scalar type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the vector.
- * @param sizes A vector specifying the size of each dimension.
- * @param data A vector containing the tensor's data.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of each dimension.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes,
-                std::vector<T> data,
-                std::vector<executorch::aten::DimOrderType> dim_order = {},
-                std::vector<executorch::aten::StridesType> strides = {},
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  if (type != deduced_type) {
-    ET_CHECK_MSG(runtime::canCast(deduced_type, type),
-                 "Cannot cast deduced type to specified type.");
-    std::vector<uint8_t> casted_data(data.size() * runtime::elementSize(type));
-    ET_SWITCH_REALHBBF16_TYPES(type, nullptr, "make_tensor_ptr", CTYPE, [&] {
-      std::transform(data.begin(), data.end(),
-                     reinterpret_cast<CTYPE *>(casted_data.data()),
-                     [](const T &val) { return static_cast<CTYPE>(val); });
-    });
-    const auto raw_data_ptr = casted_data.data();
-    auto data_ptr =
-        std::make_shared<std::vector<uint8_t>>(std::move(casted_data));
-    return make_tensor_ptr(std::move(sizes), raw_data_ptr, std::move(dim_order),
-                           std::move(strides), type, dynamism,
-                           [data_ptr = std::move(data_ptr)](void *) {});
-  }
-  const auto raw_data_ptr = data.data();
-  auto data_ptr = std::make_shared<std::vector<T>>(std::move(data));
-  return make_tensor_ptr(std::move(sizes), raw_data_ptr, std::move(dim_order),
-                         std::move(strides), type, dynamism,
-                         [data_ptr = std::move(data_ptr)](void *) {});
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload is specialized for cases where the tensor data is
- * provided as a vector. The scalar type is automatically deduced from the
- * vector's data type. If the specified `type` differs from the deduced type of
- * the vector's elements, and casting is allowed, the data will be cast to the
- * specified `type`. This allows for flexible creation of tensors with data
- * vectors of one type and a different scalar type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the vector.
- * @param data A vector containing the tensor's data.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::vector<T> data,
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  std::vector<executorch::aten::SizesType> sizes{
-      executorch::aten::SizesType(data.size())};
-  return make_tensor_ptr(std::move(sizes), std::move(data), {0}, {1}, type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload is specialized for cases where the tensor data is
- * provided as an initializer list. The scalar type is automatically deduced
- * from the initializer list's data type. If the specified `type` differs from
- * the deduced type of the initializer list's elements, and casting is allowed,
- * the data will be cast to the specified `type`. This allows for flexible
- * creation of tensors with data vectors of one type and a different scalar
- * type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the initializer
- * list.
- * @param sizes A vector specifying the size of each dimension.
- * @param list An initializer list containing the tensor's data.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of each dimension.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes,
-                std::initializer_list<T> list,
-                std::vector<executorch::aten::DimOrderType> dim_order = {},
-                std::vector<executorch::aten::StridesType> strides = {},
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return make_tensor_ptr(std::move(sizes), std::vector<T>(std::move(list)),
-                         std::move(dim_order), std::move(strides), type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload allows creating a Tensor from an initializer list
- * of data. The scalar type is automatically deduced from the type of the
- * initializer list's elements. If the specified `type` differs from
- * the deduced type of the initializer list's elements, and casting is allowed,
- * the data will be cast to the specified `type`. This allows for flexible
- * creation of tensors with data vectors of one type and a different scalar
- * type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the initializer
- * list.
- * @param list An initializer list containing the tensor's data.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::initializer_list<T> list,
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  std::vector<executorch::aten::SizesType> sizes{
-      executorch::aten::SizesType(list.size())};
-  return make_tensor_ptr(std::move(sizes), std::move(list), {0}, {1}, type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with a single scalar value.
- *
- * @tparam T The C++ type of the scalar value.
- * @param value The scalar value to be used for the Tensor.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T> inline TensorPtr make_tensor_ptr(T value) {
-  return make_tensor_ptr({}, std::vector<T>{value});
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This overload accepts a raw memory buffer stored in a std::vector<uint8_t>
- * and a scalar type to interpret the data. The vector is managed, and the
- * memory's lifetime is tied to the TensorImpl.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A vector containing the raw memory for the tensor's data.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr managing the newly created Tensor.
- */
-TensorPtr make_tensor_ptr(
-    std::vector<executorch::aten::SizesType> sizes, std::vector<uint8_t> data,
-    std::vector<executorch::aten::DimOrderType> dim_order,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND);
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This overload accepts a raw memory buffer stored in a std::vector<uint8_t>
- * and a scalar type to interpret the data. The vector is managed, and the
- * memory's lifetime is tied to the TensorImpl.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A vector containing the raw memory for the tensor's data.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr managing the newly created Tensor.
- */
-inline TensorPtr make_tensor_ptr(
-    std::vector<executorch::aten::SizesType> sizes, std::vector<uint8_t> data,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return make_tensor_ptr(std::move(sizes), std::move(data), {}, {}, type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr to manage a new Tensor with the same properties
- * as the given Tensor, sharing the same data without owning it.
- *
- * @param tensor The Tensor whose properties are used to create a new TensorPtr.
- * @return A new TensorPtr managing a Tensor with the same properties as the
- * original.
- */
-inline TensorPtr make_tensor_ptr(const executorch::aten::Tensor &tensor) {
-  return make_tensor_ptr(
-      std::vector<executorch::aten::SizesType>(tensor.sizes().begin(),
-                                               tensor.sizes().end()),
-      tensor.mutable_data_ptr(),
-#ifndef USE_ATEN_LIB
-      std::vector<executorch::aten::DimOrderType>(tensor.dim_order().begin(),
-                                                  tensor.dim_order().end()),
-      std::vector<executorch::aten::StridesType>(tensor.strides().begin(),
-                                                 tensor.strides().end()),
-      tensor.scalar_type(), tensor.shape_dynamism()
-#else  // USE_ATEN_LIB
-      {},
-      std::vector<executorch::aten::StridesType>(tensor.strides().begin(),
-                                                 tensor.strides().end()),
-      tensor.scalar_type()
-#endif // USE_ATEN_LIB
-  );
-}
-
-/**
- * Creates a TensorPtr that manages a new Tensor with the same properties
- * as the given Tensor, but with a copy of the data owned by the returned
- * TensorPtr, or nullptr if the original data is null.
- *
- * @param tensor The Tensor to clone.
- * @return A new TensorPtr that manages a Tensor with the same properties as the
- * original but with copied data.
- */
-TensorPtr clone_tensor_ptr(const executorch::aten::Tensor &tensor);
-
-/**
- * Creates a new TensorPtr by cloning the given TensorPtr, copying the
- * underlying data.
- *
- * @param tensor The TensorPtr to clone.
- * @return A new TensorPtr that manages a Tensor with the same properties as the
- * original but with copied data.
- */
-inline TensorPtr clone_tensor_ptr(const TensorPtr &tensor) {
-  return clone_tensor_ptr(*tensor);
-}
-
-/**
- * Resizes the Tensor managed by the provided TensorPtr to the new sizes.
- *
- * @param tensor A TensorPtr managing the Tensor to resize.
- * @param sizes A vector representing the new sizes for each dimension.
- * @return Error::Ok on success, or an appropriate error code on failure.
- */
-ET_NODISCARD
-runtime::Error
-resize_tensor_ptr(TensorPtr &tensor,
-                  const std::vector<executorch::aten::SizesType> &sizes);
-
-} // namespace extension
-} // namespace executorch