Keep cat_out's nnlib input arrays off variable-length stack arrays (#24319)

Summary:

`impl::G3::native::cat_out` declared variable-length arrays sized by the number of inputs (about 76 B per input) before it checked whether the `xa_nn_cat` path applies. A 256-input int64 cat in RT-DETR (`rtdetr_r18vd`, int8) therefore grew the frame by about 19 KB on the DSP thread that runs the operator, overflowed that thread's 7488 B stack and tripped the Zephyr stack sentinel on the first inference. Raising the stack did not help: 8 KB, 11.5 KB and 16 KB stacks all overflowed.

The nnlib path now runs only for same-dtype, supported-dtype cats with at most 16 inputs, and uses fixed-size arrays. Larger cats take the existing generic loop. The frame is a fixed 1440 B: the number of dynamic stack adjustments in `cat_out` goes from 11 to 0 in the built DSP image.

Adds a 40-input `cat` test case so the fallback branch is covered.

The 256 inputs are one tensor repeated: every entry of that cat references the same value and buffer. RT-DETR's decoder gathers with `topk_ind.unsqueeze(-1).repeat(1, 1, d_model)`, and Cadence's `ReplaceRepeatWithCatPass` lowers a `repeat` as a cat of the same tensor, so `d_model` = 256 becomes a 256-entry cat. The kernel is still the place to fix the overflow: the arrays are sized by entry count, not by distinct tensors, and a 100-entry cat of distinct inputs (EfficientDet-Lite0's full graph) would need about 7.6 KB of them, more than the whole 7488 B stack. Lowering `repeat` as a broadcast copy would remove RT-DETR's long list but leave genuinely wide cats exposed, so it is at most a later optimization.

Differential Revision: D128236590

Author: zonglinpeng

backends/cadence/fusion_g3/operators/op_cat.cpp

@@ -33,6 +33,12 @@ namespace impl {
 namespace G3 {
 namespace native {
 
+namespace {
+// Upper bound on inputs for the xa_nn_cat path, whose per-input arrays live on
+// the DSP thread stack. Larger cats take the generic loop.
+constexpr size_t kMaxNnlibCatInputs = 16;
+} // namespace
+
 Tensor& cat_out(
     KernelRuntimeContext& ctx,
     ArrayRef<Tensor> tensors,
@@ -42,7 +48,7 @@ Tensor& cat_out(
     dim += out.dim();
   }
 
-  int kTensorDimensionLimit = executorch::runtime::kTensorDimensionLimit;
+  constexpr int kTensorDimensionLimit = executorch::runtime::kTensorDimensionLimit;
 
 #ifdef OP_ARG_CHECK
 
@@ -76,34 +82,6 @@ Tensor& cat_out(
     return out;
   }
 
-  const signed char* inp_tensors[tensors.size()];
-  const int* inp_tensors_shapes[tensors.size()];
-
-  int inp_shapes_size[tensors.size()];
-
-  int temp_sizes[tensors.size()][kTensorDimensionLimit];
-  ArrayRef<Tensor::SizesType> temp_size;
-
-  for (int i = 0; i < tensors.size(); i++) {
-    inp_tensors[i] = tensors[i].const_data_ptr<signed char>();
-    temp_size = tensors[i].sizes();
-
-    for (int j = 0; j < temp_size.size(); j++) {
-      temp_sizes[i][j] = temp_size[j];
-    }
-    inp_tensors_shapes[i] = temp_sizes[i]; // input shapes
-    inp_shapes_size[i] = temp_size.size(); // number of input dimensions
-  }
-
-  signed char* out_data = out.mutable_data_ptr<signed char>();
-
-  const ArrayRef<Tensor::SizesType> out_size = out.sizes();
-  int out_shapes[kTensorDimensionLimit];
-  for (int i = 0; i < out_size.size(); i++) // output shapes
-  {
-    out_shapes[i] = out_size[i];
-  }
-
   bool all_same_dtype = true;
   for (int i = 0; i < tensors.size(); i++) {
     if (out.scalar_type() != tensors[i].scalar_type()) {
@@ -120,7 +98,33 @@ Tensor& cat_out(
       out.scalar_type() == ScalarType::Byte ||
       out.scalar_type() == ScalarType::Float;
 
-  if (all_same_dtype && supported_dtype) {
+  if (all_same_dtype && supported_dtype &&
+      tensors.size() <= kMaxNnlibCatInputs) {
+    const signed char* inp_tensors[kMaxNnlibCatInputs];
+    const int* inp_tensors_shapes[kMaxNnlibCatInputs];
+    int inp_shapes_size[kMaxNnlibCatInputs];
+    int temp_sizes[kMaxNnlibCatInputs][kTensorDimensionLimit];
+
+    for (int i = 0; i < tensors.size(); i++) {
+      inp_tensors[i] = tensors[i].const_data_ptr<signed char>();
+      const ArrayRef<Tensor::SizesType> temp_size = tensors[i].sizes();
+
+      for (int j = 0; j < temp_size.size(); j++) {
+        temp_sizes[i][j] = temp_size[j];
+      }
+      inp_tensors_shapes[i] = temp_sizes[i]; // input shapes
+      inp_shapes_size[i] = temp_size.size(); // number of input dimensions
+    }
+
+    signed char* out_data = out.mutable_data_ptr<signed char>();
+
+    const ArrayRef<Tensor::SizesType> out_size = out.sizes();
+    int out_shapes[kTensorDimensionLimit];
+    for (int i = 0; i < out_size.size(); i++) // output shapes
+    {
+      out_shapes[i] = out_size[i];
+    }
+
     XT_KERNEL_CHECK(
         ctx,
         out,