Arm backend: Added naming convention helper files. (#16373)

Added files to help verify naming convention is followed for arm test
suite.

Signed-off-by: Michiel Olieslagers <[email protected]>

Author: Michiel-Olieslagers

backends/arm/MODELS.md

@@ -0,0 +1,20 @@
+# The following file contains all models that have been confirmed to be functional and tested for the Arm backend:
+- Conformer
+- Deit Tiny
+- DeepLab v3 (DL3)
+- Inception v3 (IC3)
+- Llama
+- Long Short-Term Memory (LSTM)
+- MobileNet v2 (MV2)
+- MobileNet v3 (MV3)
+- Some popular torch.nn.functional models (NN functional)
+- Some popular torch.nn.modules models (NN modules)
+- Some popular torch ops (Torch Functions)
+- Neural Super Sampler (NSS)
+- ResNet 18
+- Wav2Letter (W2L)
+- Stable Diffusion:
+    * CLIP Text Encoder (CLIP Text with Projection)
+    * Stable Diffusion 3 Transformer (SD3 Transformer)
+    * T5 Encoder
+    * VAE Encoder/Decoder (VAE)

backends/arm/scripts/collect_testname_resources.py

@@ -0,0 +1,194 @@
+# Copyright 2025 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+import ast
+import pathlib
+import re
+
+from executorch.exir.dialects.edge.spec.utils import SAMPLE_INPUT as _SAMPLE_INPUT
+
+# Add all targets and TOSA profiles we support here.
+TARGETS = [
+    "tosa_FP",
+    "tosa_INT",
+    "tosa_INT+FP",
+    "u55_INT",
+    "u85_INT",
+    "vgf_INT",
+    "vgf_FP",
+    "vgf_quant",
+    "vgf_no_quant",
+    "no_target",
+]
+
+# Add edge ops which we lower but which are not included in exir/dialects/edge/edge.yaml here.
+_CUSTOM_EDGE_OPS = [
+    "linspace.default",
+    "cond.default",
+    "eye.default",
+    "expm1.default",
+    "vector_norm.default",
+    "hardsigmoid.default",
+    "hardswish.default",
+    "linear.default",
+    "maximum.default",
+    "mean.default",
+    "multihead_attention.default",
+    "adaptive_avg_pool2d.default",
+    "bitwise_right_shift.Tensor",
+    "bitwise_right_shift.Scalar",
+    "bitwise_left_shift.Tensor",
+    "bitwise_left_shift.Scalar",
+    "native_group_norm.default",
+    "silu.default",
+    "sdpa.default",
+    "sum.default",
+    "unbind.int",
+    "unflatten.int",
+    "_native_batch_norm_legit_no_training.default",
+    "_native_batch_norm_legit.no_stats",
+    "alias_copy.default",
+    "pixel_shuffle.default",
+    "pixel_unshuffle.default",
+    "while_loop.default",
+    "matmul.default",
+    "upsample_bilinear2d.vec",
+    "upsample_nearest2d.vec",
+]
+_ALL_EDGE_OPS = _SAMPLE_INPUT.keys() | _CUSTOM_EDGE_OPS
+
+_NON_ARM_PASSES = ["quantize_io_pass"]
+
+_MODEL_ENTRY_PATTERN = re.compile(r"^\s*(?:[-*]|\d+\.)\s+(?P<entry>.+?)\s*$")
+_NUMERIC_SERIES_PATTERN = re.compile(r"(\d+)(?=[a-z])")
+_CAMEL_BOUNDARY = re.compile(
+    r"(?<!^)(?:(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z]))"
+)
+
+
+def _collect_arm_passes(init_path: pathlib.Path) -> set[str]:
+    names: set[str] = set()
+    names.update(_extract_pass_names_from_init(init_path))
+    names.update(_NON_ARM_PASSES)
+    return {_separate_numeric_series(_strip_pass_suffix(name)) for name in names}
+
+
+def _extract_pass_names_from_init(init_path: pathlib.Path) -> set[str]:
+    source = init_path.read_text(encoding="utf-8")
+    module = ast.parse(source, filename=str(init_path))
+    names: set[str] = set()
+
+    for node in module.body:
+        if not isinstance(node, ast.ImportFrom):
+            continue
+        for alias in node.names:
+            candidate = alias.asname or alias.name
+            if not candidate or not candidate.endswith("Pass"):
+                continue
+            if candidate == "ArmPass":
+                continue
+            names.add(_camel_to_snake(candidate))
+    return names
+
+
+def _strip_pass_suffix(name: str) -> str:
+    return name[:-5] if name.endswith("_pass") else name
+
+
+def _separate_numeric_series(name: str) -> str:
+    def repl(match: re.Match[str]) -> str:
+        next_index = match.end()
+        next_char = match.string[next_index] if next_index < len(match.string) else ""
+        if next_char == "d":  # Avoid creating patterns like 3_d
+            return match.group(1)
+        return f"{match.group(1)}_"
+
+    return _NUMERIC_SERIES_PATTERN.sub(repl, name)
+
+
+def _collect_arm_models(models_md: pathlib.Path) -> set[str]:
+    models: set[str] = set()
+    for line in models_md.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        match = _MODEL_ENTRY_PATTERN.match(line)
+        if not match:
+            continue
+        base, alias, is_parent = _split_model_entry(match.group("entry"))
+        if is_parent:
+            continue
+        if alias:
+            models.add(_normalize_model_entry(alias))
+        else:
+            models.add(_normalize_model_entry(base))
+
+    if not models:
+        raise RuntimeError(f"No supported models found in {models_md}")
+    return models
+
+
+def _collect_arm_ops() -> set[str]:
+    """
+    Returns a mapping from names on the form to be used in unittests to edge op:
+    1. Names are in lowercase.
+    2. Overload is ignored if 'default', otherwise it's appended with an underscore.
+    3. Overly verbose name are shortened by removing certain prefixes/suffixes.
+
+    Examples:
+        abs.default -> abs
+        split_copy.Tensor -> split_tensor
+    """
+    ops: set[str] = set()
+    for edge_name in _ALL_EDGE_OPS:
+        op, overload = edge_name.split(".")
+
+        # Normalize names
+        op = op.lower()
+        op = op.removeprefix("_")
+        op = op.removesuffix("_copy")
+        op = op.removesuffix("_with_indices")
+        overload = overload.lower()
+
+        if overload == "default":
+            ops.add(op)
+        else:
+            ops.add(f"{op}_{overload}")
+
+    return ops
+
+
+def _split_model_entry(entry: str) -> tuple[str, str | None, bool]:
+    entry = entry.strip()
+    if not entry:
+        return "", None, False
+    is_parent = entry.endswith(":")
+    if is_parent:
+        entry = entry[:-1].rstrip()
+    if "(" in entry and entry.endswith(")"):
+        base, _, rest = entry.partition("(")
+        alias = rest[:-1].strip()
+        return base.strip(), alias or None, is_parent
+    return entry, None, is_parent
+
+
+def _normalize_model_entry(name: str) -> str:
+    cleaned = name.lower()
+    cleaned = re.sub(r"[^a-z0-9\s]", "", cleaned)
+    cleaned = re.sub(r"\s+", " ", cleaned).strip()
+    return cleaned.replace(" ", "_")
+
+
+def _camel_to_snake(name: str) -> str:
+    if not name:
+        return ""
+    name = name.replace("-", "_").replace(" ", "_")
+    return _CAMEL_BOUNDARY.sub("_", name).lower()
+
+
+OP_LIST = sorted(_collect_arm_ops())
+PASS_LIST = sorted(
+    _collect_arm_passes(pathlib.Path("backends/arm/_passes/__init__.py"))
+)
+MODEL_LIST = sorted(_collect_arm_models(pathlib.Path("backends/arm/MODELS.md")))