fix(runtime): tensors_have_same_dim_order Tier A legacy + Tier B semantic (Alternative A)

- Tier A: restore all_contiguous || all_channels_last over full list (pre-PR C contract) so mixed-rank and broadcast call sites pass.
- Tier B: when Tier A fails, same-rank tensors use semantic equivalence to ref; different-rank must match ref contiguous vs channels_last family.
- Parity: apply same logic in tensor_util_aten.cpp (two_tensors_semantic_same_layout).
- Docs in tensor_util.h; rename different-rank test to DifferentRankSameLegacyFormatFamilyPasses.

Fixes unittest-editable regressions from pairwise-only dim_order checks while preserving #16032 degenerate-shape behavior.

Author: NefAI

runtime/core/exec_aten/util/tensor_util.h

@@ -1280,37 +1280,34 @@ bool tensor_is_default_dim_order(executorch::aten::Tensor t);
 bool tensor_is_channels_last_dim_order(executorch::aten::Tensor t);
 
 /**
- * Asserts that four tensors have the same dim_order
+ * Returns true if all tensors are in a compatible layout for portable kernels.
  *
- * Note that this macro only tests dim order, but not others like actual data,
- * sizes, etc.
+ * First, the legacy rule: either every tensor is contiguous-order
+ * (`is_contiguous_dim_order`) or every tensor is channels-last-order
+ * (`is_channels_last_dim_order`). That matches mixed-rank argument lists
+ * (e.g. batch norm with reduced outputs), broadcast shapes, and typical
+ * elementwise ops.
  *
+ * If that fails, falls back to semantic equivalence for tensors with the same
+ * rank as the first tensor: matching dim_order labels, or matching strides on
+ * non-size-1 dimensions (degenerate-shape / ambiguous dim_order cases).
+ * Tensors with a different rank than the first must match the first tensor's
+ * format family (both contiguous-order, or both channels-last-order).
+ *
+ * Does not validate sizes, dtypes, or data.
  */
 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.
- */
-
+/** @see tensors_have_same_dim_order(ArrayRef) */
 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.
- *
- */
-
+/** @see tensors_have_same_dim_order(ArrayRef) */
 inline bool tensors_have_same_dim_order(
     const executorch::aten::Tensor& a,
     const executorch::aten::Tensor& b,
@@ -1319,14 +1316,7 @@ inline bool tensors_have_same_dim_order(
   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.
- *
- */
-
+/** @see tensors_have_same_dim_order(ArrayRef) */
 inline bool tensors_have_same_dim_order(
     const executorch::aten::Tensor& a,
     const executorch::aten::Tensor& b,

runtime/core/exec_aten/util/tensor_util_aten.cpp

@@ -78,6 +78,46 @@ inline bool tensor_is_default_or_channels_last_dim_order(at::Tensor t) {
   return ret_val;
 }
 
+namespace {
+
+// Same-rank semantic layout match (dim_order labels, else strides with
+// size-1 dims skipped). Used when the legacy format-family check fails.
+bool two_tensors_semantic_same_layout(
+    const executorch::aten::Tensor& a,
+    const executorch::aten::Tensor& b) {
+  if (a.dim() != b.dim()) {
+    return false;
+  }
+  const int ndim = static_cast<int>(a.dim());
+  executorch::aten::DimOrderType order_a[kTensorDimensionLimit];
+  executorch::aten::DimOrderType order_b[kTensorDimensionLimit];
+  if (get_dim_order(a, order_a, a.dim()) != Error::Ok ||
+      get_dim_order(b, order_b, b.dim()) != Error::Ok) {
+    return false;
+  }
+  bool labels_match = true;
+  for (int i = 0; i < ndim; ++i) {
+    if (order_a[i] != order_b[i]) {
+      labels_match = false;
+      break;
+    }
+  }
+  if (labels_match) {
+    return true;
+  }
+  for (int i = 0; i < ndim; ++i) {
+    if (a.size(i) == 1 && b.size(i) == 1) {
+      continue;
+    }
+    if (a.stride(i) != b.stride(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace
+
 bool tensors_have_same_dim_order(
     const executorch::aten::ArrayRef<executorch::aten::Tensor> tensor_list) {
   if (tensor_list.size() < 2) {
@@ -110,12 +150,50 @@ bool tensors_have_same_dim_order(
         is_channels_last_dim_order(other_dim_order, tensor_list[i].dim());
   }
 
-  ET_CHECK_OR_RETURN_FALSE(
-      all_contiguous || all_channels_last,
-      "%zd input tensors have different dim orders",
-      tensor_list.size());
+  if (all_contiguous || all_channels_last) {
+    return true;
+  }
+
+  const executorch::aten::Tensor& ref = tensor_list[0];
+  const bool ref_contiguous =
+      is_contiguous_dim_order(first_dim_order, ref.dim());
+  const bool ref_channels_last =
+      is_channels_last_dim_order(first_dim_order, ref.dim());
 
-  return all_contiguous || all_channels_last;
+  for (size_t i = 1; i < tensor_list.size(); ++i) {
+    const executorch::aten::Tensor& t = tensor_list[i];
+    if (t.dim() == ref.dim()) {
+      if (!two_tensors_semantic_same_layout(ref, t)) {
+        ET_LOG(
+            Error,
+            "%zd input tensors have different dim orders",
+            tensor_list.size());
+        return false;
+      }
+    } else {
+      if (get_dim_order(t, other_dim_order, t.dim()) != Error::Ok) {
+        ET_LOG(
+            Error,
+            "%zd input tensors have different dim orders",
+            tensor_list.size());
+        return false;
+      }
+      const bool t_contiguous =
+          is_contiguous_dim_order(other_dim_order, t.dim());
+      const bool t_channels_last =
+          is_channels_last_dim_order(other_dim_order, t.dim());
+      const bool ok = (ref_contiguous && t_contiguous) ||
+          (ref_channels_last && t_channels_last);
+      if (!ok) {
+        ET_LOG(
+            Error,
+            "%zd input tensors have different dim orders",
+            tensor_list.size());
+        return false;
+      }
+    }
+  }
+  return true;
 }
 
 namespace internal {

runtime/core/exec_aten/util/tensor_util_portable.cpp

@@ -154,20 +154,69 @@ bool two_tensors_same_dim_order(
   return true;
 }
 
+// Tier A: every tensor is contiguous-order or every tensor is channels-last
+// (original portable contract). Handles mixed rank, broadcast shapes, and
+// reduced aux outputs (e.g. batch norm mean tensors).
+bool tensors_share_legacy_format_family(
+    const executorch::aten::ArrayRef<executorch::aten::Tensor> tensor_list) {
+  bool all_contiguous = true;
+  bool all_channels_last = true;
+  for (const auto i : c10::irange(tensor_list.size())) {
+    all_contiguous = all_contiguous &&
+        is_contiguous_dim_order(
+            tensor_list[i].dim_order().data(),
+            tensor_list[i].dim_order().size());
+    all_channels_last = all_channels_last &&
+        is_channels_last_dim_order(
+            tensor_list[i].dim_order().data(),
+            tensor_list[i].dim_order().size());
+  }
+  return all_contiguous || all_channels_last;
+}
+
 } // namespace
 
 bool tensors_have_same_dim_order(
     const executorch::aten::ArrayRef<executorch::aten::Tensor> tensor_list) {
   if (tensor_list.size() < 2) {
     return true;
   }
+
+  if (tensors_share_legacy_format_family(tensor_list)) {
+    return true;
+  }
+
+  const executorch::aten::Tensor& ref = tensor_list[0];
+  const bool ref_contiguous =
+      is_contiguous_dim_order(ref.dim_order().data(), ref.dim_order().size());
+  const bool ref_channels_last =
+      is_channels_last_dim_order(ref.dim_order().data(), ref.dim_order().size());
+
   for (size_t i = 1; i < tensor_list.size(); ++i) {
-    if (!two_tensors_same_dim_order(tensor_list[0], tensor_list[i])) {
-      ET_LOG(
-          Error,
-          "%zd input tensors have different dim orders",
-          tensor_list.size());
-      return false;
+    const executorch::aten::Tensor& t = tensor_list[i];
+    if (t.dim() == ref.dim()) {
+      if (!two_tensors_same_dim_order(ref, t)) {
+        ET_LOG(
+            Error,
+            "%zd input tensors have different dim orders",
+            tensor_list.size());
+        return false;
+      }
+    } else {
+      const bool t_contiguous =
+          is_contiguous_dim_order(t.dim_order().data(), t.dim_order().size());
+      const bool t_channels_last =
+          is_channels_last_dim_order(t.dim_order().data(), t.dim_order().size());
+      const bool ok =
+          (ref_contiguous && t_contiguous) ||
+          (ref_channels_last && t_channels_last);
+      if (!ok) {
+        ET_LOG(
+            Error,
+            "%zd input tensors have different dim orders",
+            tensor_list.size());
+        return false;
+      }
     }
   }
   return true;

runtime/core/exec_aten/util/test/tensor_util_test.cpp

@@ -692,13 +692,14 @@ TEST_F(TensorUtilTest, SemanticEquivalencePartialDegenerateFails) {
   EXPECT_FALSE(tensors_have_same_dim_order(nchw, nhwc));
 }
 
-TEST_F(TensorUtilTest, SemanticEquivalenceDifferentRankFails) {
+TEST_F(TensorUtilTest, DifferentRankSameLegacyFormatFamilyPasses) {
   using namespace torch::executor;
-  // Different ranks should fail
+  // Legacy rule: all contiguous-order (or all channels-last) passes even when
+  // ranks differ (e.g. reduced outputs vs full activations).
   Tensor a = tf_float_.ones({2, 3, 4, 4});
   Tensor b = tf_float_.ones({2, 3, 4});
 
-  EXPECT_FALSE(tensors_have_same_dim_order(a, b));
+  EXPECT_TRUE(tensors_have_same_dim_order(a, b));
 }
 
 TEST_F(TensorUtilTest, SemanticEquivalenceSameLabelsSameResult) {