react-native-executorch 0.4.8 → 0.5.1-rc.0

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64-simulator/Headers/executorch/runtime/core/exec_aten/util/tensor_util.h

@@ -0,0 +1,1250 @@
+/*
+ * 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 <array> // std::array
+#include <c10/util/irange.h>
+#include <cinttypes> // PRId64
+#include <cmath>
+#include <cstddef> // size_t
+
+#include <limits>
+
+#include <executorch/runtime/core/array_ref.h>
+#include <executorch/runtime/core/error.h>
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/core/exec_aten/util/dim_order_util.h>
+#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
+#include <executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h>
+#include <executorch/runtime/core/span.h>
+#include <executorch/runtime/platform/assert.h>
+#include <executorch/runtime/platform/compiler.h>
+
+/// All assertion messages should begin with this prefix.
+#define ET_TENSOR_CHECK_PREFIX__ "Tensors do not match"
+#define ET_MIN2(a, b) (std::min(a, b))
+#define ET_MIN3(a, b, c) (std::min(a, std::min(b, c)))
+
+#define ET_NORMALIZE_IX(IX, UPPER_BOUND) IX < 0 ? IX + UPPER_BOUND : IX
+
+#define ET_CHECK_VALID_IX(IX, UPPER_BOUND)                                     \
+  ET_CHECK_MSG(IX >= -static_cast<int64_t>(UPPER_BOUND) &&                     \
+                   IX < static_cast<int64_t>(UPPER_BOUND),                     \
+               "index %" PRId64 " must be within range [-%zd, %zd)", IX,       \
+               UPPER_BOUND, UPPER_BOUND)
+
+#define ET_CHECK_VALID_DIM(DIM, UPPER_BOUND)                                   \
+  ET_CHECK_MSG(DIM >= -static_cast<int64_t>(UPPER_BOUND) &&                    \
+                   DIM < static_cast<int64_t>(UPPER_BOUND),                    \
+               "dim %" PRId64 " must be within range [-%zd, %zd)", DIM,        \
+               UPPER_BOUND, UPPER_BOUND)
+
+#define ET_CHECK_NON_ZERO_DIM_SIZE(DIM, T)                                     \
+  const size_t udim = ET_NORMALIZE_IX(DIM, T.dim());                           \
+  ET_CHECK_MSG(T.size(udim) != 0, "Expected dim %zd to have non-zero size.",   \
+               udim);
+
+/**
+ * Asserts that all tensors have the same shape.
+ * This also handles a edge case where there is only one element in all the
+ * tensors being compared but the number of dimensions >= 0. In the for loop
+ * iterating over the dimensions we make sure that we pick the smallest
+ * dimension of all the tensors as the upper bound for the for loop.
+ */
+#define ET_CHECK_SAME_SHAPE2(a__, b__)                                         \
+  ({                                                                           \
+    const size_t a_numel__ = (a__).numel();                                    \
+    const size_t b_numel__ = (b__).numel();                                    \
+    const size_t a_dim__ = (a__).dim();                                        \
+    const size_t b_dim__ = (b__).dim();                                        \
+    ET_CHECK_MSG(                                                              \
+        a_numel__ == b_numel__ &&                                              \
+            ((a_numel__ == 1 && b_numel__ == 1) || (a_dim__ == b_dim__)),      \
+        ET_TENSOR_CHECK_PREFIX__ ": numel={%zu, %zu}, dim={%zu, %zu}",         \
+        a_numel__, b_numel__, a_dim__, b_dim__);                               \
+    for (size_t dim__ = 0; dim__ < ET_MIN2(a_dim__, b_dim__); ++dim__) {       \
+      size_t a_size__ = (a__).size(dim__);                                     \
+      size_t b_size__ = (b__).size(dim__);                                     \
+      ET_CHECK_MSG(a_size__ == b_size__,                                       \
+                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu}",       \
+                   dim__, a_size__, b_size__);                                 \
+    }                                                                          \
+  })
+
+#define ET_CHECK_SAME_SHAPE3(a__, b__, c__)                                    \
+  ({                                                                           \
+    const size_t a_numel__ = (a__).numel();                                    \
+    const size_t b_numel__ = (b__).numel();                                    \
+    const size_t c_numel__ = (c__).numel();                                    \
+    const size_t a_dim__ = (a__).dim();                                        \
+    const size_t b_dim__ = (b__).dim();                                        \
+    const size_t c_dim__ = (c__).dim();                                        \
+    ET_CHECK_MSG(a_numel__ == b_numel__ && b_numel__ == c_numel__ &&           \
+                     ((a_numel__ == 1 && b_numel__ == 1 && c_numel__ == 1) ||  \
+                      a_dim__ == b_dim__ && b_dim__ == c_dim__),               \
+                 ET_TENSOR_CHECK_PREFIX__                                      \
+                 ": numel={%zu, %zu, %zu}, dim={%zu, %zu, %zu}",               \
+                 a_numel__, b_numel__, c_numel__, a_dim__, b_dim__, c_dim__);  \
+    for (size_t dim__ = 0; dim__ < ET_MIN3(a_dim__, b_dim__, c_dim__);         \
+         ++dim__) {                                                            \
+      size_t a_size__ = (a__).size(dim__);                                     \
+      size_t b_size__ = (b__).size(dim__);                                     \
+      size_t c_size__ = (c__).size(dim__);                                     \
+      ET_CHECK_MSG(a_size__ == b_size__ && b_size__ == c_size__,               \
+                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu, %zu}",  \
+                   dim__, a_size__, b_size__, c_size__);                       \
+    }                                                                          \
+  })
+
+/// Asserts that all tensors have the same dtype.
+#define ET_CHECK_SAME_DTYPE2(a__, b__)                                         \
+  ({                                                                           \
+    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
+    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
+    ET_CHECK_MSG(a_type__ == b_type__,                                         \
+                 ET_TENSOR_CHECK_PREFIX__ ": dtype={%" PRId8 ", %" PRId8 "}",  \
+                 static_cast<int8_t>(a_type__),                                \
+                 static_cast<int8_t>(b_type__));                               \
+  })
+
+#define ET_CHECK_SAME_DTYPE3(a__, b__, c__)                                    \
+  ({                                                                           \
+    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
+    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
+    const ::executorch::aten::ScalarType c_type__ = (c__).scalar_type();       \
+    ET_CHECK_MSG(a_type__ == b_type__ && b_type__ == c_type__,                 \
+                 ET_TENSOR_CHECK_PREFIX__ ": dtype={%" PRId8 ", %" PRId8       \
+                                          ", %" PRId8 "}",                     \
+                 static_cast<int8_t>(a_type__), static_cast<int8_t>(b_type__), \
+                 static_cast<int8_t>(c_type__));                               \
+  })
+
+/**
+ * Asserts that all tensors have the same shape and dtype.
+ *
+ * This macro should produce less code/data than calling the SHAPE and DTYPE
+ * macros independently, because it only calls ET_CHECK_MSG once.
+ */
+#define ET_CHECK_SAME_SHAPE_AND_DTYPE2(a__, b__)                               \
+  ({                                                                           \
+    const size_t a_numel__ = (a__).numel();                                    \
+    const size_t b_numel__ = (b__).numel();                                    \
+    const size_t a_dim__ = (a__).dim();                                        \
+    const size_t b_dim__ = (b__).dim();                                        \
+    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
+    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
+                                                                               \
+    ET_CHECK_MSG(                                                              \
+        a_numel__ == b_numel__ &&                                              \
+            ((a_numel__ == 1 && b_numel__ == 1) || a_dim__ == b_dim__) &&      \
+            a_type__ == b_type__,                                              \
+        ET_TENSOR_CHECK_PREFIX__                                               \
+        ": numel={%zu, %zu}, dim={%zu, %zu}, dtype={%" PRId8 ", %" PRId8 "}",  \
+        a_numel__, b_numel__, a_dim__, b_dim__, static_cast<int8_t>(a_type__), \
+        static_cast<int8_t>(b_type__));                                        \
+    for (size_t dim__ = 0; dim__ < ET_MIN2(a_dim__, b_dim__); ++dim__) {       \
+      size_t a_size__ = (a__).size(dim__);                                     \
+      size_t b_size__ = (b__).size(dim__);                                     \
+      ET_CHECK_MSG(a_size__ == b_size__,                                       \
+                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu}",       \
+                   dim__, a_size__, b_size__);                                 \
+    }                                                                          \
+  })
+
+#define ET_CHECK_SAME_SHAPE_AND_DTYPE3(a__, b__, c__)                          \
+  ({                                                                           \
+    const size_t a_numel__ = (a__).numel();                                    \
+    const size_t b_numel__ = (b__).numel();                                    \
+    const size_t c_numel__ = (c__).numel();                                    \
+    const size_t a_dim__ = (a__).dim();                                        \
+    const size_t b_dim__ = (b__).dim();                                        \
+    const size_t c_dim__ = (c__).dim();                                        \
+    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
+    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
+    const ::executorch::aten::ScalarType c_type__ = (c__).scalar_type();       \
+                                                                               \
+    ET_CHECK_MSG(a_numel__ == b_numel__ && b_numel__ == c_numel__ &&           \
+                     ((a_numel__ == 1 && b_numel__ == 1 && c_numel__ == 1) ||  \
+                      (a_dim__ == b_dim__ && b_dim__ == c_dim__)) &&           \
+                     a_type__ == b_type__ && b_type__ == c_type__,             \
+                 ET_TENSOR_CHECK_PREFIX__                                      \
+                 ": numel={%zu, %zu, %zu}, dim={%zu, %zu, %zu}, "              \
+                 "dtype={%" PRId8 ", %" PRId8 ", %" PRId8 "}",                 \
+                 a_numel__, b_numel__, c_numel__, a_dim__, b_dim__, c_dim__,   \
+                 static_cast<int8_t>(a_type__), static_cast<int8_t>(b_type__), \
+                 static_cast<int8_t>(c_type__));                               \
+    for (size_t dim__ = 0; dim__ < ET_MIN3(a_dim__, b_dim__, c_dim__);         \
+         ++dim__) {                                                            \
+      size_t a_size__ = (a__).size(dim__);                                     \
+      size_t b_size__ = (b__).size(dim__);                                     \
+      size_t c_size__ = (c__).size(dim__);                                     \
+      ET_CHECK_MSG(a_size__ == b_size__ && b_size__ == c_size__,               \
+                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu, %zu}",  \
+                   dim__, a_size__, b_size__, c_size__);                       \
+    }                                                                          \
+  })
+
+/**
+ * Assert that the input tensor is contiguous tensor.
+ */
+#define ET_CHECK_CONTIGUOUS(a__)                                               \
+  ({                                                                           \
+    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
+        strides = a__.strides();                                               \
+    const ::executorch::aten::ArrayRef<executorch::aten::StridesType> sizes =  \
+        a__.sizes();                                                           \
+    ET_CHECK_MSG(                                                              \
+        strides[strides.size() - 1] == 1,                                      \
+        "The stride of the last dimension shall be 1 for contiguous tensor, "  \
+        "not %d",                                                              \
+        strides[strides.size() - 1]);                                          \
+    for (size_t i = strides.size() - 1; i > 0; i--) {                          \
+      ET_CHECK_MSG(strides[i - 1] == strides[i] * sizes[i],                    \
+                   "The stride of the %zu-th dimension shall equal to "        \
+                   "strides[%zu] * sizes[%zu], now is %d and %d",              \
+                   i - 1, i, i, strides[i - 1], strides[i] * sizes[i]);        \
+    }                                                                          \
+  })
+
+/**
+ * Assert the input two tensors share same strides.
+ * Noted that this function does not make any check or promise on the contiguity
+ * of any input tensors.
+ */
+#define ET_CHECK_SAME_STRIDES2(a__, b__)                                       \
+  ({                                                                           \
+    ET_CHECK_MSG(                                                              \
+        a__.dim() == b__.dim(),                                                \
+        "Two tensors shall have same number of strides, but not %zu and %zu.", \
+        a__.dim(), b__.dim());                                                 \
+    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
+        a_strides = a__.strides();                                             \
+    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
+        b_strides = b__.strides();                                             \
+    for (size_t i = 0; i < a__.dim(); i++) {                                   \
+      ET_CHECK_MSG(a_strides[i] == b_strides[i],                               \
+                   "a.strides()[%zu] shall equal to b.strides()[%zu], "        \
+                   "but now is %d and %d.",                                    \
+                   i, i, (int32_t)a_strides[i], (int32_t)b_strides[i]);        \
+    }                                                                          \
+  })
+
+/**
+ * Assert the input three tensors share same strides.
+ * Noted that this function does not make any check or promise on the contiguity
+ * of any input tensors.
+ */
+#define ET_CHECK_SAME_STRIDES3(a__, b__, c__)                                  \
+  ({                                                                           \
+    ET_CHECK_MSG(a__.dim() == b__.dim() && b__.dim() == c__.dim(),             \
+                 "Three tensors shall have same number of strides, "           \
+                 "but not %zu, %zu and %zu.",                                  \
+                 a__.dim(), b__.dim(), c__.dim());                             \
+    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
+        a_strides = a__.strides();                                             \
+    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
+        b_strides = b__.strides();                                             \
+    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
+        c_strides = c__.strides();                                             \
+    for (size_t i = 0; i < a__.dim(); i++) {                                   \
+      ET_CHECK_MSG(a_strides[i] == b_strides[i] &&                             \
+                       b_strides[i] == c_strides[i],                           \
+                   "a_strides[%zu], b_strides[%zu] and c_strides[%zu] "        \
+                   "shall share same value, but now is %d, %d and %d",         \
+                   i, i, i, (int32_t)a_strides[i], (int32_t)b_strides[i],      \
+                   (int32_t)c_strides[i]);                                     \
+    }                                                                          \
+  })
+
+#define ET_CHECK_DEFAULT_OR_CHANNELSLAST_DIMORDER(t__)                         \
+  ({                                                                           \
+    ET_CHECK_MSG(is_contiguous_dim_order(t__.dim_order().data(),               \
+                                         t__.dim_order().size()) ||            \
+                     is_channels_last_dim_order(t__.dim_order().data(),        \
+                                                t__.dim_order().size()),       \
+                 "Tensor must have default or channels last dim order");       \
+  })
+
+/**
+ * DEPRECATED: Please use ET_CHECK_OR_RETURN_FALSE instead and provide
+ * an informative message. (For example, the values of any variables used in
+ * `cond` would not be reported automatically by this macro.)
+ *
+ * A convenience macro to be used in utility functions that check whether input
+ * tensor(s) are valid, which are expected to return a boolean. Checks whether
+ * `cond` is true; if not, log the failed check and return false.
+ *
+ * @param[in] cond the condition to check
+ */
+#define ET_LOG_AND_RETURN_IF_FALSE(cond) ET_CHECK_OR_RETURN_FALSE(cond, "")
+
+/**
+ * DEPRECATED: Please use ET_CHECK_OR_RETURN_FALSE instead.
+ */
+#define ET_LOG_MSG_AND_RETURN_IF_FALSE ET_CHECK_OR_RETURN_FALSE
+
+/**
+ * If `cond` is false, log `cond` and return from the kernel with a failure
+ * state set.
+ *
+ * @param[in] context the runtime context
+ * @param[in] cond the condition to check
+ * @param[in] error torch::executor::Error enum value (e.g `InvalidArgument`)
+ * @param[in] retval return value of the kernel to allow for early exit
+ */
+#define ET_KERNEL_CHECK(context, cond, error, retval)                          \
+  do {                                                                         \
+    if (!(cond)) {                                                             \
+      ET_LOG(Error, "Check failed (%s): ", #cond);                             \
+      context.fail(torch::executor::Error::error);                             \
+      return retval;                                                           \
+    }                                                                          \
+  } while (false)
+
+/**
+ * If `cond` is false, log `message` and return from the kernel with a failure
+ * state set.
+ *
+ * @param[in] context the runtime context
+ * @param[in] cond the condition to check
+ * @param[in] error torch::executor::Error enum value (e.g `InvalidArgument`)
+ * @param[in] retval return value of the kernel to allow for early exit
+ */
+#define ET_KERNEL_CHECK_MSG(context, cond, error, retval, message, ...)        \
+  do {                                                                         \
+    if (!(cond)) {                                                             \
+      ET_LOG(Error, "Check failed (%s): " message, #cond, ##__VA_ARGS__);      \
+      context.fail(torch::executor::Error::error);                             \
+      return retval;                                                           \
+    }                                                                          \
+  } while (false)
+
+/**
+ * Convenience macro to extract a scalar tensor into a value
+ */
+#define ET_EXTRACT_SCALAR_TENSOR(scalar_tensor, out_val)                       \
+  ET_CHECK_MSG(extract_scalar_tensor(scalar_tensor, &out_val), #scalar_tensor  \
+               " could not be extracted: wrong type or out of range");
+
+namespace executorch {
+namespace runtime {
+
+//
+// Utility functions for checking tensor attributes
+//
+//
+
+/*
+ * Returns true if the given dimension value is between -upper_bound and
+ * upper_bound - 1, inclusive.
+ */
+inline bool dim_is_valid(int64_t dim, int64_t upper_bound) {
+  ET_CHECK_OR_RETURN_FALSE(
+      dim >= -upper_bound && dim < upper_bound,
+      "Dimension %" PRId64
+      " is out of range. Dimension should be between %" PRId64 " and %" PRId64
+      ", inclusive.",
+      dim, -upper_bound, upper_bound - 1);
+
+  return true;
+}
+
+/*
+ * Returns the tensor's number of dimensions, except when the tensor is zero
+ * dimensional. In this case, it returns 1. This is used to properly handle
+ * the zero dimensional tensors in some kernels, that treat them as 1D tensors
+ * with a single element.
+ */
+inline ssize_t nonzero_dim(const executorch::aten::Tensor &tensor) {
+  return tensor.dim() == 0 ? 1 : tensor.dim();
+}
+
+/*
+ * Returns the size along a dimension dim, except when the tensor is zero
+ * dimensional. In this case, it returns 1. This is used to properly handle
+ * the zero dimensional tensors in some kernels, that treat them as 1D tensors
+ * with a single element.
+ */
+inline ssize_t nonempty_size(const executorch::aten::Tensor &tensor,
+                             ssize_t dim) {
+  return tensor.dim() == 0 ? 1 : tensor.size(dim);
+}
+
+inline bool tensor_can_cast_to(executorch::aten::Tensor a,
+                               executorch::aten::ScalarType dtype) {
+  ET_CHECK_OR_RETURN_FALSE(torch::executor::canCast(a.scalar_type(), dtype),
+                           "Tensor of dtype %s cannot cast to dtype %s",
+                           torch::executor::toString(a.scalar_type()),
+                           torch::executor::toString(dtype));
+
+  return true;
+}
+
+inline bool tensor_is_bool_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(t.scalar_type() ==
+                               executorch::aten::ScalarType::Bool,
+                           "Expected to find bool type, but tensor has type %s",
+                           torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_type(executorch::aten::Tensor t,
+                           executorch::aten::ScalarType dtype) {
+  ET_CHECK_OR_RETURN_FALSE(t.scalar_type() == dtype,
+                           "Expected to find %s type, but tensor has type %s",
+                           torch::executor::toString(dtype),
+                           torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_type(executorch::aten::Tensor t,
+                           executorch::aten::ScalarType dtype,
+                           executorch::aten::ScalarType dtype2) {
+  ET_LOG_MSG_AND_RETURN_IF_FALSE(
+      t.scalar_type() == dtype || t.scalar_type() == dtype2,
+      "Expected to find %s or %s type, but tensor has type %s",
+      torch::executor::toString(dtype), torch::executor::toString(dtype2),
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_type(executorch::aten::Tensor t,
+                           executorch::aten::ScalarType dtype,
+                           executorch::aten::ScalarType dtype2,
+                           executorch::aten::ScalarType dtype3) {
+  ET_LOG_MSG_AND_RETURN_IF_FALSE(
+      t.scalar_type() == dtype || t.scalar_type() == dtype2 ||
+          t.scalar_type() == dtype3,
+      "Expected to find %s, %s, or %s type, but tensor has type %s",
+      torch::executor::toString(dtype), torch::executor::toString(dtype2),
+      torch::executor::toString(dtype3),
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_integral_type(executorch::aten::Tensor t,
+                                    bool includeBool = false) {
+  ET_CHECK_OR_RETURN_FALSE(
+      torch::executor::isIntegralType(t.scalar_type(), includeBool),
+      "Expected to find a integral type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_floating_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      torch::executor::isFloatingType(t.scalar_type()),
+      "Expected to find a floating type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_real_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      torch::executor::isRealType(t.scalar_type()),
+      "Expected to find a real type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_realh_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      torch::executor::isRealHType(t.scalar_type()),
+      "Expected to find a real type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_realhbf16_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      executorch::runtime::isRealHBF16Type(t.scalar_type()),
+      "Expected to find a real type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_realhb_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      torch::executor::isRealHBType(t.scalar_type()),
+      "Expected to find a real type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_realhbbf16_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      executorch::runtime::isRealHBBF16Type(t.scalar_type()),
+      "Expected to find a real type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_complex_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      torch::executor::isComplexType(t.scalar_type()),
+      "Expected to find a complex type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensor_is_bits_type(executorch::aten::Tensor t) {
+  ET_CHECK_OR_RETURN_FALSE(
+      torch::executor::isBitsType(t.scalar_type()),
+      "Expected to find a bits type, but tensor has type %s",
+      torch::executor::toString(t.scalar_type()));
+
+  return true;
+}
+
+inline bool tensors_have_same_dtype(executorch::aten::Tensor a,
+                                    executorch::aten::Tensor b) {
+  ET_CHECK_OR_RETURN_FALSE(a.scalar_type() == b.scalar_type(),
+                           ET_TENSOR_CHECK_PREFIX__ ": dtype={%s, %s}",
+                           torch::executor::toString(a.scalar_type()),
+                           torch::executor::toString(b.scalar_type()));
+  return true;
+}
+
+inline bool tensors_have_same_dtype(executorch::aten::Tensor a,
+                                    executorch::aten::Tensor b,
+                                    executorch::aten::Tensor c) {
+  ET_CHECK_OR_RETURN_FALSE(a.scalar_type() == b.scalar_type() &&
+                               b.scalar_type() == c.scalar_type(),
+                           ET_TENSOR_CHECK_PREFIX__ ": dtype={%s, %s, %s}",
+                           torch::executor::toString(a.scalar_type()),
+                           torch::executor::toString(b.scalar_type()),
+                           torch::executor::toString(c.scalar_type()));
+  return true;
+}
+
+inline bool tensor_is_rank(executorch::aten::Tensor t, size_t rank) {
+  ET_CHECK_OR_RETURN_FALSE(static_cast<size_t>(t.dim()) == rank,
+                           "Expected tensor.dim() to be %zu, but got %zu",
+                           static_cast<size_t>(rank),
+                           static_cast<size_t>(t.dim()));
+
+  return true;
+}
+
+inline bool tensor_has_rank_greater_or_equal_to(executorch::aten::Tensor t,
+                                                size_t rank) {
+  ET_CHECK_OR_RETURN_FALSE(static_cast<size_t>(t.dim()) >= rank,
+                           "Expected tensor.dim() to be >= %zu, but got %zu",
+                           static_cast<size_t>(rank),
+                           static_cast<size_t>(t.dim()));
+
+  return true;
+}
+
+inline bool tensor_has_rank_smaller_or_equal_to(executorch::aten::Tensor t,
+                                                size_t rank) {
+  ET_CHECK_OR_RETURN_FALSE(static_cast<size_t>(t.dim()) <= rank,
+                           "Expected tensor.dim() to be <= %zu, but got %zu",
+                           static_cast<size_t>(rank),
+                           static_cast<size_t>(t.dim()));
+
+  return true;
+}
+
+inline bool tensor_has_dim(executorch::aten::Tensor t, int64_t d) {
+  if (t.dim() == 0) {
+    ET_CHECK_OR_RETURN_FALSE(
+        d == 0 || d == -1, "dim must be 0 or -1 for 0-dim tensor, got %" PRId64,
+        d);
+  } else {
+    ET_CHECK_OR_RETURN_FALSE(d > 0 ? d < t.dim() : t.dim() + d >= 0,
+                             "%zu-dim tensor does not have dim at index %zu",
+                             static_cast<size_t>(t.dim()),
+                             static_cast<size_t>(d));
+  }
+  return true;
+}
+
+inline bool tensor_has_non_empty_dim(executorch::aten::Tensor t, int64_t d) {
+  const size_t udim = ET_NORMALIZE_IX(d, t.dim());
+  ET_LOG_AND_RETURN_IF_FALSE(tensor_has_dim(t, d));
+  ET_LOG_AND_RETURN_IF_FALSE(t.size(udim) != 0);
+  return true;
+}
+
+inline bool tensor_dim_has_index(executorch::aten::Tensor t, int64_t d,
+                                 int64_t ix) {
+  // Indexing ops don't support zero-dim tensors
+  ET_CHECK(t.dim() != 0);
+  if (d < 0) {
+    d += t.dim();
+  }
+  // Dimension must have been already checked by tensor_has_dim
+  ET_CHECK(d >= 0 && d < t.dim());
+
+  ET_CHECK_OR_RETURN_FALSE(
+      ix >= -t.size(d) && ix < t.size(d),
+      "index %" PRId64 " out of range [-%zu,%zu) at dimension %" PRId64 ")", ix,
+      static_cast<size_t>(t.size(d)), static_cast<size_t>(t.size(d)), d);
+  return true;
+}
+
+inline bool tensors_have_same_size_at_dims(executorch::aten::Tensor a,
+                                           size_t dim_a,
+                                           executorch::aten::Tensor b,
+                                           size_t dim_b) {
+  ET_CHECK_OR_RETURN_FALSE(dim_a < static_cast<size_t>(a.dim()),
+                           "Cannot retrieve dim %zu from tensor with dim %zu",
+                           static_cast<size_t>(dim_a),
+                           static_cast<size_t>(a.dim()));
+  ET_CHECK_OR_RETURN_FALSE(dim_b < static_cast<size_t>(b.dim()),
+                           "Cannot retrieve dim %zu from tensor with dim %zu",
+                           static_cast<size_t>(dim_b),
+                           static_cast<size_t>(b.dim()));
+  ET_CHECK_OR_RETURN_FALSE(
+      a.size(dim_a) == b.size(dim_b),
+      ET_TENSOR_CHECK_PREFIX__
+      ": a.size(%zu) = %zu does not match b.size(%zu) = %zu",
+      static_cast<size_t>(dim_a), static_cast<size_t>(a.size(dim_a)),
+      static_cast<size_t>(dim_b), static_cast<size_t>(b.size(dim_b)));
+
+  return true;
+}
+
+inline bool tensors_have_same_shape(executorch::aten::Tensor a,
+                                    executorch::aten::Tensor b) {
+  if (a.numel() == 1 && b.numel() == 1) {
+    // PyTorch operators treat all scalar tensors as the same shape even if
+    // they have different dims.
+    return true;
+  }
+  if (!(a.sizes() == b.sizes() && a.numel() == b.numel())) {
+    ET_LOG(Error,
+           ET_TENSOR_CHECK_PREFIX__ ": numel=(%zu,  %zu), dim=(%zu, %zu)",
+           static_cast<size_t>(a.numel()), static_cast<size_t>(b.numel()),
+           static_cast<size_t>(a.dim()), static_cast<size_t>(b.dim()));
+    // Using [[maybe_unused]] as ET_LOG may not trigger based on verbosity
+    for ([[maybe_unused]] const auto d :
+         c10::irange(ET_MIN2(a.dim(), b.dim()))) {
+      ET_LOG(Error, "    size(%zu): (%zu, %zu)", static_cast<size_t>(d),
+             static_cast<size_t>(a.size(d)), static_cast<size_t>(b.size(d)));
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+inline bool tensors_have_same_shape(executorch::aten::Tensor a,
+                                    executorch::aten::Tensor b,
+                                    executorch::aten::Tensor c) {
+  if (a.numel() == 1 && b.numel() == 1 && c.numel() == 1) {
+    // PyTorch operators treat all scalar tensors as the same shape even if
+    // they have different dims.
+    return true;
+  }
+  bool cond1 = (a.sizes() == b.sizes()) && (a.numel() == b.numel());
+  bool cond2 = (b.sizes() == c.sizes()) && (b.numel() == c.numel());
+
+  if (!(cond1 && cond2)) {
+    ET_LOG(Error,
+           ET_TENSOR_CHECK_PREFIX__
+           ": numel=(%zu, %zu, %zu), dim=(%zu, %zu, %zu)",
+           static_cast<size_t>(a.numel()), static_cast<size_t>(b.numel()),
+           static_cast<size_t>(c.numel()), static_cast<size_t>(a.dim()),
+           static_cast<size_t>(b.dim()), static_cast<size_t>(c.dim()));
+    for ([[maybe_unused]] const auto d :
+         c10::irange(ET_MIN3(a.dim(), b.dim(), c.dim()))) {
+      ET_LOG(Error, "    size(%zu): (%zu, %zu, %zu)", static_cast<size_t>(d),
+             static_cast<size_t>(a.size(d)), static_cast<size_t>(b.size(d)),
+             static_cast<size_t>(c.size(d)));
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+inline bool tensors_have_same_shape_and_dtype(executorch::aten::Tensor a,
+                                              executorch::aten::Tensor b) {
+  return tensors_have_same_shape(a, b) && tensors_have_same_dtype(a, b);
+}
+
+inline bool tensors_have_same_shape_and_dtype(executorch::aten::Tensor a,
+                                              executorch::aten::Tensor b,
+                                              executorch::aten::Tensor c) {
+  return tensors_have_same_shape(a, b, c) && tensors_have_same_dtype(a, b, c);
+}
+
+inline bool tensor_has_expected_size(
+    executorch::aten::Tensor a,
+    executorch::aten::ArrayRef<executorch::aten::SizesType> expected_sizes) {
+  if (!(a.sizes() == expected_sizes)) {
+    ET_LOG(Error, ET_TENSOR_CHECK_PREFIX__ ": dim=(%zu, %zu)",
+           static_cast<size_t>(a.dim()),
+           static_cast<size_t>(expected_sizes.size()));
+    size_t a_dim = static_cast<size_t>(a.dim());
+    size_t expected_dim = static_cast<size_t>(expected_sizes.size());
+    for ([[maybe_unused]] const auto d :
+         c10::irange(ET_MIN2(a_dim, expected_dim))) {
+      ET_LOG(Error, "    size(%zu): (%zu, %zu)", static_cast<size_t>(d),
+             static_cast<size_t>(a.size(d)),
+             static_cast<size_t>(expected_sizes[d]));
+    }
+
+    return false;
+  }
+  return true;
+}
+
+inline bool tensors_have_same_strides(executorch::aten::Tensor a,
+                                      executorch::aten::Tensor b) {
+  if (a.strides() != b.strides()) {
+    ET_LOG(Error, ET_TENSOR_CHECK_PREFIX__ ": dim=(%zu, %zu)",
+           static_cast<size_t>(a.dim()), static_cast<size_t>(b.dim()));
+    for ([[maybe_unused]] const auto d :
+         c10::irange(ET_MIN2(a.dim(), b.dim()))) {
+      ET_LOG(Error, "    stride(%zu): (%zu, %zu)", static_cast<size_t>(d),
+             static_cast<size_t>(a.strides()[d]),
+             static_cast<size_t>(b.strides()[d]));
+    }
+
+    return false;
+  }
+  return true;
+}
+
+inline bool tensors_have_same_strides(executorch::aten::Tensor a,
+                                      executorch::aten::Tensor b,
+                                      executorch::aten::Tensor c) {
+  if (!(a.strides() == b.strides() && b.strides() == c.strides())) {
+    ET_LOG(Error, ET_TENSOR_CHECK_PREFIX__ ": dim=(%zu, %zu, %zu)",
+           static_cast<size_t>(a.dim()), static_cast<size_t>(b.dim()),
+           static_cast<size_t>(c.dim()));
+    for ([[maybe_unused]] const auto d :
+         c10::irange(ET_MIN3(a.dim(), b.dim(), c.dim()))) {
+      ET_LOG(Error, "    stride(%zu): (%zu, %zu, %zu)", static_cast<size_t>(d),
+             static_cast<size_t>(a.strides()[d]),
+             static_cast<size_t>(b.strides()[d]),
+             static_cast<size_t>(c.strides()[d]));
+    }
+
+    return false;
+  }
+  return true;
+}
+
+inline bool tensor_is_contiguous(executorch::aten::Tensor t) {
+  const auto strides = t.strides();
+  const auto sizes = t.sizes();
+  // If tensor is 0-dim (i.e. a scalar tensor) it is contiguous
+  if (strides.size() == 0) {
+    return true;
+  }
+  ET_CHECK_OR_RETURN_FALSE(
+      strides[strides.size() - 1] == 1,
+      "Tensor is not contiguous; the stride of the last dimension must be 1, "
+      "but got %zu",
+      static_cast<size_t>(strides[strides.size() - 1]));
+  for (int i = strides.size() - 1; i > 0; --i) {
+    ET_CHECK_OR_RETURN_FALSE(
+        strides[i - 1] == strides[i] * sizes[i],
+        "Tensor is not contiguous; the stride of dim %zu should be equal to "
+        "strides[%zu] * sizes[%zu] = %zu, but found %zu",
+        static_cast<size_t>(i - 1), static_cast<size_t>(i),
+        static_cast<size_t>(i), static_cast<size_t>(strides[i] * sizes[i]),
+        static_cast<size_t>(strides[i - 1]));
+  }
+  return true;
+}
+
+inline bool tensors_have_same_rank(executorch::aten::Tensor a,
+                                   executorch::aten::Tensor b) {
+  ET_CHECK_OR_RETURN_FALSE(a.dim() == b.dim(),
+                           ET_TENSOR_CHECK_PREFIX__ ": rank={%zd, %zd}",
+                           ssize_t(a.dim()), ssize_t(b.dim()));
+  return true;
+}
+
+inline bool tensor_is_scalar(executorch::aten::Tensor t) {
+  return t.dim() == 0 && t.numel() == 1;
+}
+
+/// Returns the product of dim[0:dim), not including dim.
+inline size_t getLeadingDims(const executorch::aten::Tensor &tensor,
+                             int64_t dim) {
+  ET_CHECK_MSG(dim >= 0 && dim <= tensor.dim(),
+               "Ending dimension %" PRId64
+               " should be in the range [0, tensor.dim() %zd].",
+               dim, ssize_t(tensor.dim()));
+  size_t dims = 1;
+  for (const auto i : c10::irange(dim)) {
+    dims *= static_cast<size_t>(tensor.size(i));
+  }
+  return dims;
+}
+
+/// Returns the product of dim[dim+1:].
+inline size_t getTrailingDims(const executorch::aten::Tensor &tensor,
+                              int64_t dim) {
+  ET_CHECK_MSG(dim >= -1 && dim < tensor.dim(),
+               "Starting dimension %" PRId64
+               " should be in the range [-1, tensor.dim() -1 %zd).",
+               dim, ssize_t(tensor.dim()));
+  size_t dims = 1;
+  for (size_t i = dim + 1; i < static_cast<size_t>(tensor.dim()); ++i) {
+    dims *= static_cast<size_t>(tensor.size(i));
+  }
+  return dims;
+}
+
+/**
+ * Given a N-dimensional tensor coordinate, return a linear index that can be
+ * used to access the corresponding element in the tensor's data buffer.
+ *
+ * @param[in] tensor The tensor that will be indexed
+ * @param[in] coordinate A n-dimensional array representing the coordinate to
+ * index. It is assumed that the array has kTensorDimensionLimit elements.
+ * @param[out] index The linear index to element at the specified coordinate
+ * in the tensor.
+ */
+inline size_t coordinateToIndex(const executorch::aten::Tensor &tensor,
+                                const size_t *const coordinate) {
+  size_t index = 0;
+  for (int d = 0; d < tensor.dim(); ++d) {
+    index += coordinate[d] * getTrailingDims(tensor, d);
+  }
+  return index;
+}
+
+/**
+ * Produce a memoized array for use with repeated calls to
+ * coordinateToIndexWithTrailingDimsMemo, which will be faster than
+ * repeated calls to coordinateToIndex.
+ */
+inline void
+memoizeTrailingDims(const executorch::aten::Tensor &tensor,
+                    size_t trailing_dims_memo[kTensorDimensionLimit]) {
+  const auto tensorDim = tensor.dim();
+  size_t dims = 1;
+  for (int ii = tensorDim - 1; ii >= 0; --ii) {
+    trailing_dims_memo[ii] = dims;
+    dims *= static_cast<size_t>(tensor.size(ii));
+  }
+}
+
+/**
+ * Like coordinateToIndex, but faster for repeated calls with the same
+ * tensor. trailing_dims_memo must be produced by a call to
+ * memoizeTrailingDims.
+ */
+inline size_t coordinateToIndexWithTrailingDimsMemo(
+    const executorch::aten::Tensor &tensor, const size_t *const coordinate,
+    const size_t trailing_dims_memo[kTensorDimensionLimit]) {
+  size_t index = 0;
+  for (int d = 0; d < tensor.dim(); ++d) {
+    index += coordinate[d] * trailing_dims_memo[d];
+  }
+  return index;
+}
+
+/**
+ * Given the linear index return the N-dimensional tensor coordinate. This is
+ * the inverse operation of coordinateToIndex.
+ *
+ * @param[in] tensor The tensor that will be indexed
+ * @param[in] index The linear index to element at the specified coordinate in
+ * the tensor.
+ * @param[out] coordinate A n-dimensional array representing the coordinate to
+ * index. It is assumed that the array has kTensorDimensionLimit elements.
+ * @returns void
+ */
+inline void indexToCoordinate(const executorch::aten::Tensor &tensor,
+                              size_t index, size_t *coordinate) {
+  ET_CHECK(index < static_cast<size_t>(tensor.numel()));
+  for (auto i = 0; i < tensor.dim(); ++i) {
+    auto dim = tensor.dim() - 1 - i;
+    size_t dim_size = tensor.size(dim);
+    coordinate[dim] = index % dim_size;
+    index /= dim_size;
+  }
+}
+
+/**
+ * Extracts an integer value from a scalar Tensor.
+ *
+ * @param[in] tensor The source of the value to extract.
+ * @param[out] out_val The extracted value, on success.
+ * @returns `true` if a value was extracted, and sets `*out_val` to that
+ * value. `false` if a value could not be extracted: either it was not an
+ * integer Scalar Tensor, or the value of that Scalar Tensor could not be
+ * represented by INT_T.
+ */
+template <typename INT_T,
+          typename std::enable_if<std::is_integral<INT_T>::value &&
+                                      !std::is_same<INT_T, bool>::value,
+                                  bool>::type = true>
+bool extract_scalar_tensor(executorch::aten::Tensor tensor, INT_T *out_val) {
+  if (tensor.numel() != 1) {
+    return false;
+  }
+#define CASE_INT_DTYPE(TENSOR_CTYPE, TENSOR_DTYPE)                             \
+  case executorch::aten::ScalarType::TENSOR_DTYPE: {                           \
+    const TENSOR_CTYPE val = tensor.const_data_ptr<TENSOR_CTYPE>()[0];         \
+    if (val < std::numeric_limits<INT_T>::lowest() ||                          \
+        val > std::numeric_limits<INT_T>::max()) {                             \
+      return false;                                                            \
+    }                                                                          \
+    *out_val = static_cast<INT_T>(val);                                        \
+    return true;                                                               \
+  }
+
+  switch (tensor.scalar_type()) {
+    ET_FORALL_INT_TYPES(CASE_INT_DTYPE);
+  default:
+    return false;
+  }
+#undef CASE_INT_DTYPE
+}
+
+/**
+ * Extracts a floating point value from a scalar Tensor.
+ *
+ * @param[in] tensor The source of the value to extract.
+ * @param[out] out_val The extracted value, on success.
+ * @returns `true` if a value was extracted, and sets `*out_val` to that
+ * value. `false` if a value could not be extracted: either it was not a
+ * floating point Scalar Tensor, or the value of that Scalar Tensor could not
+ * be represented by FLOAT_T.
+ */
+template <typename FLOAT_T,
+          typename std::enable_if<
+              std::is_floating_point_v<FLOAT_T> ||
+                  std::is_same_v<FLOAT_T, executorch::aten::BFloat16> ||
+                  std::is_same_v<FLOAT_T, executorch::aten::Half>,
+              bool>::type = true>
+bool extract_scalar_tensor(executorch::aten::Tensor tensor, FLOAT_T *out_val) {
+  if (tensor.numel() != 1) {
+    return false;
+  }
+#define CASE_REAL_DTYPE(TENSOR_CTYPE, TENSOR_DTYPE)                            \
+  case executorch::aten::ScalarType::TENSOR_DTYPE: {                           \
+    /* ET_FORALL_REAL_TYPES guarantees TENSOR_CTYPE is a real type. */         \
+    double val =                                                               \
+        static_cast<double>(tensor.const_data_ptr<TENSOR_CTYPE>()[0]);         \
+    if (std::isfinite(val) && (val < std::numeric_limits<FLOAT_T>::lowest() || \
+                               val > std::numeric_limits<FLOAT_T>::max())) {   \
+      return false;                                                            \
+    }                                                                          \
+    *out_val = static_cast<FLOAT_T>(val);                                      \
+    return true;                                                               \
+  }
+
+  switch (tensor.scalar_type()) {
+    ET_FORALL_REALHBF16_TYPES(CASE_REAL_DTYPE);
+  default:
+    return false;
+  }
+#undef CASE_REAL_DTYPE
+}
+
+/**
+ * Extracts a boolean value from a Scalar.
+ *
+ * @param[in] scalar The source of the value to extract.
+ * @param[out] out_val The extracted value, on success.
+ * @returns `true` if a value was extracted, and sets `*out_val` to that
+ * value. `false` if a value could not be extracted, i.e. not a boolean
+ */
+template <typename BOOL_T,
+          typename std::enable_if<std::is_same<BOOL_T, bool>::value,
+                                  bool>::type = true>
+bool extract_scalar_tensor(executorch::aten::Tensor tensor, BOOL_T *out_val) {
+  if (tensor.scalar_type() != executorch::aten::ScalarType::Bool) {
+    return false;
+  }
+  if (tensor.numel() != 1) {
+    return false;
+  }
+
+  bool val = tensor.const_data_ptr<bool>()[0];
+
+  *out_val = static_cast<BOOL_T>(val);
+
+  return true;
+}
+
+/// These APIs should not be used outside of Executor.cpp.
+namespace internal {
+/**
+ * Share t_src's data_ptr with t_dst.
+ */
+ET_NODISCARD Error share_tensor_data(const executorch::aten::Tensor &t_dst,
+                                     const executorch::aten::Tensor &t_src);
+
+/**
+ * Copy t_src's data_ptr to t_dst.
+ */
+ET_NODISCARD Error copy_tensor_data(const executorch::aten::Tensor &t_dst,
+                                    const executorch::aten::Tensor &t_src);
+
+/**
+ * Set the data_ptr of t to buffer.
+ */
+ET_NODISCARD Error set_tensor_data(const executorch::aten::Tensor &t,
+                                   void *buffer, size_t buffer_size);
+
+/**
+ * Reset tensor's data_ptr, clear all the storage for at::Tensor.
+ */
+void reset_data_ptr(const executorch::aten::Tensor &tensor);
+
+/**
+ * Resize tensor impl
+ */
+ET_NODISCARD Error resize_tensor_impl(
+    executorch::aten::TensorImpl *impl,
+    executorch::aten::ArrayRef<executorch::aten::SizesType> new_sizes);
+
+} // namespace internal
+
+/**
+ * Resize a tensor to new_sizes, rank must stay the same. Currently does not
+ * expand the tensor if new size exceeds the current capacity. Currently
+ * fails an ET_CHECK if the tensor cannot be resized.
+ *
+ * WARNING: Placeholder API until discussion around runtime context is
+ * settled, will likely move to be a class method on a TensorResizer object
+ * passed in through runtimeContext.
+ */
+ET_NODISCARD inline Error resize_tensor(
+    executorch::aten::Tensor t,
+    executorch::aten::ArrayRef<executorch::aten::SizesType> new_sizes) {
+  return internal::resize_tensor_impl(t.unsafeGetTensorImpl(), new_sizes);
+}
+
+/**
+ * Resize a tensor to new_sizes, rank must stay the same. Currently does not
+ * expand the tensor if new size exceeds the current capacity. Currently
+ * fails an ET_CHECK if the tensor cannot be resized.
+ *
+ * WARNING: Placeholder API until discussion around runtime context is
+ * settled, will likely move to be a class method on a TensorResizer object
+ * passed in through runtimeContext.
+ */
+template <typename T, typename std::enable_if<
+                          !std::is_same<executorch::aten::SizesType, T>::value,
+                          int>::type = 0>
+ET_NODISCARD inline Error
+resize_tensor(executorch::aten::Tensor t,
+              executorch::aten::ArrayRef<T> new_sizes) {
+  // Need to cast the input array to an array of Tensor::SizesType
+  std::array<executorch::aten::SizesType, kTensorDimensionLimit>
+      new_sizes_casted{};
+  size_t new_sizes_ndim = new_sizes.size();
+  for (size_t i = 0; i < new_sizes_ndim; ++i) {
+    new_sizes_casted[i] =
+        static_cast<executorch::aten::SizesType>(new_sizes[i]);
+  }
+
+  return internal::resize_tensor_impl(
+      t.unsafeGetTensorImpl(), {new_sizes_casted.data(), new_sizes_ndim});
+}
+
+/// DEPRECATED: Use `resize_tensor()` instead, which can fail non-fatally.
+ET_DEPRECATED inline void
+resize(executorch::aten::Tensor t,
+       executorch::aten::ArrayRef<executorch::aten::SizesType> new_sizes) {
+  Error err = resize_tensor(t, new_sizes);
+  ET_CHECK_MSG(err == Error::Ok,
+               "Could not resize Tensor; see logs for details");
+}
+/**
+ * Get dim_order of a Tensor and write it to out_dim_order.
+ * @param tensor The tensor where we want to get dim order from.
+ * @param out_dim_order Pointing to an array of DimOrderType where we write
+ * dim order into it.
+ * @param out_dim_order_size Size of the DimOrderType array.
+ */
+ET_NODISCARD Error get_dim_order(const executorch::aten::Tensor &tensor,
+                                 executorch::aten::DimOrderType *out_dim_order,
+                                 size_t out_dim_order_size);
+
+/**
+ * Checks whether a tensor has a valid dim order. If the dim order could not
+ * be determined, then this function returns false by default.
+ */
+bool tensor_has_valid_dim_order(executorch::aten::Tensor t);
+
+/**
+ * Checks whether a tensor has either the default of channels last dim order.
+ * If the dim order could not be determined, then this function returns false
+ * by default.
+ */
+bool tensor_is_default_or_channels_last_dim_order(executorch::aten::Tensor t);
+
+/**
+ * Checks whether a tensor has the default dimension order.
+ * Logs an error message if the tensor does not meet the expected criteria.
+ *
+ * @param t The tensor to check the dimension order of.
+ * @return True if the tensor has the default dimension order, false otherwise.
+ */
+bool tensor_is_default_dim_order(executorch::aten::Tensor t);
+
+/**
+ * Checks whether a tensor has the channels last dimension order.
+ * Logs an error message if the tensor does not meet the expected criteria.
+ *
+ * @param t The tensor to check the dimension order of.
+ * @return True if the tensor has the channels last dimension order, false
+ * otherwise.
+ */
+bool tensor_is_channels_last_dim_order(executorch::aten::Tensor t);
+
+/**
+ * Asserts that four tensors have the same dim_order
+ *
+ * Note that this macro only tests dim order, but not others like actual data,
+ * sizes, etc.
+ *
+ */
+bool tensors_have_same_dim_order(
+    const executorch::aten::ArrayRef<executorch::aten::Tensor> tensor_list);
+
+/**
+ * Asserts that two tensors have the same dim_order
+ *
+ * Note that this macro only tests dim order, but not others like actual data,
+ * sizes, etc.
+ */
+
+inline bool tensors_have_same_dim_order(const executorch::aten::Tensor &a,
+                                        const executorch::aten::Tensor &b) {
+  executorch::aten::Tensor tensor_list[2] = {a, b};
+  return tensors_have_same_dim_order(tensor_list);
+}
+
+/**
+ * Asserts that three tensors have the same dim_order
+ *
+ * Note that this macro only tests dim order, but not others like actual data,
+ * sizes, etc.
+ *
+ */
+
+inline bool tensors_have_same_dim_order(const executorch::aten::Tensor &a,
+                                        const executorch::aten::Tensor &b,
+                                        const executorch::aten::Tensor &c) {
+  executorch::aten::Tensor tensor_list[3] = {a, b, c};
+  return tensors_have_same_dim_order(tensor_list);
+}
+
+/**
+ * Asserts that four tensors have the same dim_order
+ *
+ * Note that this macro only tests dim order, but not others like actual data,
+ * sizes, etc.
+ *
+ */
+
+inline bool tensors_have_same_dim_order(const executorch::aten::Tensor &a,
+                                        const executorch::aten::Tensor &b,
+                                        const executorch::aten::Tensor &c,
+                                        const executorch::aten::Tensor &d) {
+  executorch::aten::Tensor tensor_list[4] = {a, b, c, d};
+  return tensors_have_same_dim_order(tensor_list);
+}
+
+/**
+ * Given an n-dimensional coordinate array and an array of tensor strides,
+ * calculates the linear index that can be used to retrieve the value at the
+ * given coordinates.
+ * @param coordinate Pointer to the array of coordinates.
+ * @param strides Pointer to the array of strides.
+ * @param ndim Number of dimensions in the tensor.
+ */
+inline size_t
+calculate_linear_index(const executorch::aten::SizesType *coordinate,
+                       const executorch::aten::StridesType *strides,
+                       const size_t ndim) {
+  size_t index = 0;
+  for (size_t i = 0; i < ndim; i++) {
+    index += coordinate[i] * strides[i];
+  }
+  return index;
+}
+
+} // 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::calculate_linear_index;
+using ::executorch::runtime::coordinateToIndex;
+using ::executorch::runtime::dim_is_valid;
+using ::executorch::runtime::extract_scalar_tensor;
+using ::executorch::runtime::get_dim_order;
+using ::executorch::runtime::getLeadingDims;
+using ::executorch::runtime::getTrailingDims;
+using ::executorch::runtime::indexToCoordinate;
+using ::executorch::runtime::kTensorDimensionLimit;
+using ::executorch::runtime::nonempty_size;
+using ::executorch::runtime::nonzero_dim;
+using ::executorch::runtime::resize;
+using ::executorch::runtime::resize_tensor;
+using ::executorch::runtime::tensor_can_cast_to;
+using ::executorch::runtime::tensor_dim_has_index;
+using ::executorch::runtime::tensor_has_dim;
+using ::executorch::runtime::tensor_has_expected_size;
+using ::executorch::runtime::tensor_has_non_empty_dim;
+using ::executorch::runtime::tensor_has_rank_greater_or_equal_to;
+using ::executorch::runtime::tensor_has_rank_smaller_or_equal_to;
+using ::executorch::runtime::tensor_has_valid_dim_order;
+using ::executorch::runtime::tensor_is_bits_type;
+using ::executorch::runtime::tensor_is_bool_type;
+using ::executorch::runtime::tensor_is_complex_type;
+using ::executorch::runtime::tensor_is_contiguous;
+using ::executorch::runtime::tensor_is_default_dim_order;
+using ::executorch::runtime::tensor_is_default_or_channels_last_dim_order;
+using ::executorch::runtime::tensor_is_floating_type;
+using ::executorch::runtime::tensor_is_integral_type;
+using ::executorch::runtime::tensor_is_rank;
+using ::executorch::runtime::tensor_is_real_type;
+using ::executorch::runtime::tensor_is_realh_type;
+using ::executorch::runtime::tensor_is_realhb_type;
+using ::executorch::runtime::tensor_is_scalar;
+using ::executorch::runtime::tensors_have_same_dim_order;
+using ::executorch::runtime::tensors_have_same_dtype;
+using ::executorch::runtime::tensors_have_same_rank;
+using ::executorch::runtime::tensors_have_same_shape;
+using ::executorch::runtime::tensors_have_same_shape_and_dtype;
+using ::executorch::runtime::tensors_have_same_size_at_dims;
+using ::executorch::runtime::tensors_have_same_strides;
+namespace internal {
+using ::executorch::runtime::internal::copy_tensor_data;
+using ::executorch::runtime::internal::reset_data_ptr;
+using ::executorch::runtime::internal::resize_tensor_impl;
+using ::executorch::runtime::internal::set_tensor_data;
+using ::executorch::runtime::internal::share_tensor_data;
+} // namespace internal
+} // namespace executor
+} // namespace torch