executorch 1.1.0__cp313-cp313-win_amd64.whl

executorch/include/executorch/runtime/core/exec_aten/util/tensor_util.h

@@ -0,0 +1,1415 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <c10/util/irange.h>
+#include <algorithm>
+#include <array> // std::array
+#include <cinttypes> // PRId64
+#include <cmath>
+#include <cstddef> // size_t
+
+#include <limits>
+
+#include <c10/util/irange.h>
+#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__)                                    \
+  do {                                                                    \
+    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__);                                                      \
+    }                                                                     \
+  } while (0)
+
+#define ET_CHECK_SAME_SHAPE3(a__, b__, c__)                            \
+  do {                                                                 \
+    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__);                                                   \
+    }                                                                  \
+  } while (0)
+
+/// Asserts that all tensors have the same dtype.
+#define ET_CHECK_SAME_DTYPE2(a__, b__)                                   \
+  do {                                                                   \
+    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__));                                  \
+  } while (0)
+
+#define ET_CHECK_SAME_DTYPE3(a__, b__, c__)                                 \
+  do {                                                                      \
+    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__));                                     \
+  } while (0)
+
+/**
+ * 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__)                              \
+  do {                                                                        \
+    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__);                                                          \
+    }                                                                         \
+  } while (0)
+
+#define ET_CHECK_SAME_SHAPE_AND_DTYPE3(a__, b__, c__)                    \
+  do {                                                                   \
+    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__);                                                     \
+    }                                                                    \
+  } while (0)
+
+/**
+ * Assert that the input tensor is contiguous tensor.
+ */
+#define ET_CHECK_CONTIGUOUS(a__)                                              \
+  do {                                                                        \
+    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]);                                             \
+    }                                                                         \
+  } while (0)
+
+/**
+ * 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__)                                       \
+  do {                                                                         \
+    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 (const auto i : c10::irange(a__.dim())) {                              \
+      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]);                                              \
+    }                                                                          \
+  } while (0)
+
+/**
+ * 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__)                           \
+  do {                                                                  \
+    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 (const auto i : c10::irange(a__.dim())) {                       \
+      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]);                                       \
+    }                                                                   \
+  } while (0)
+
+#define ET_CHECK_DEFAULT_OR_CHANNELSLAST_DIMORDER(t__)           \
+  do {                                                           \
+    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");  \
+  } while (0)
+
+/**
+ * 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 ET_RUNTIME_NAMESPACE {
+//
+// 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 (const auto d : c10::irange(tensor.dim())) {
+    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 (const auto d : c10::irange(tensor.dim())) {
+    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 (const auto i : c10::irange(tensor.dim())) {
+    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();
+  ET_CHECK_OR_RETURN_ERROR(
+      new_sizes_ndim <= kTensorDimensionLimit,
+      InvalidArgument,
+      "new_sizes_ndim %zu is greater than kTensorDimensionLimit %zu",
+      new_sizes_ndim,
+      kTensorDimensionLimit);
+  for (const auto i : c10::irange(new_sizes_ndim)) {
+    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 (const auto i : c10::irange(ndim)) {
+    index += coordinate[i] * strides[i];
+  }
+  return index;
+}
+
+} // namespace ET_RUNTIME_NAMESPACE
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::ET_RUNTIME_NAMESPACE::calculate_linear_index;
+using ::executorch::ET_RUNTIME_NAMESPACE::coordinateToIndex;
+using ::executorch::ET_RUNTIME_NAMESPACE::dim_is_valid;
+using ::executorch::ET_RUNTIME_NAMESPACE::extract_scalar_tensor;
+using ::executorch::ET_RUNTIME_NAMESPACE::get_dim_order;
+using ::executorch::ET_RUNTIME_NAMESPACE::getLeadingDims;
+using ::executorch::ET_RUNTIME_NAMESPACE::getTrailingDims;
+using ::executorch::ET_RUNTIME_NAMESPACE::indexToCoordinate;
+using ::executorch::ET_RUNTIME_NAMESPACE::nonempty_size;
+using ::executorch::ET_RUNTIME_NAMESPACE::nonzero_dim;
+using ::executorch::ET_RUNTIME_NAMESPACE::resize;
+using ::executorch::ET_RUNTIME_NAMESPACE::resize_tensor;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_can_cast_to;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_dim_has_index;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_dim;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_expected_size;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_non_empty_dim;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_rank_greater_or_equal_to;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_rank_smaller_or_equal_to;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_valid_dim_order;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_bits_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_bool_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_complex_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_contiguous;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_default_dim_order;
+using ::executorch::ET_RUNTIME_NAMESPACE::
+    tensor_is_default_or_channels_last_dim_order;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_floating_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_integral_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_rank;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_real_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_realh_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_realhb_type;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_scalar;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_dim_order;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_dtype;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_rank;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_shape;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_shape_and_dtype;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_size_at_dims;
+using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_strides;
+using ::executorch::runtime::kTensorDimensionLimit;
+namespace internal {
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::copy_tensor_data;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::reset_data_ptr;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::resize_tensor_impl;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::set_tensor_data;
+using ::executorch::ET_RUNTIME_NAMESPACE::internal::share_tensor_data;
+} // namespace internal
+} // namespace executor
+} // namespace torch