change resolve_defined_ops back

Author: baonudesifeizhai

vllm/compilation/partition_rules.py

@@ -22,59 +22,27 @@ def resolve_defined_ops(op_names: list[str]) -> list[torch._ops.OpOverload]:
     Skips operators that fail to resolve (e.g., operators not registered or
     model-specific operators not present in the current model).
 
-    If an operator name doesn't specify an overload (e.g., "vllm::unified_attention"),
-    it will automatically use the .default overload.
-
     Note: Users should inspect the operator graph before lowering and ensure
     the specified operators are present in the final graph. Built-in PyTorch
     operators (aten::*, torch::*) may be decomposed, fused, or transformed
     during Inductor's compilation passes, so use them with caution.
 
     Args:
         op_names: List of operator names in PyTorch format
-            (e.g., "vllm::unified_attention" or "vllm::unified_attention.default")
+            (e.g., "vllm::unified_attention.default")
 
     Returns:
         List of successfully resolved operator overloads
     """
-    resolved: list[torch._ops.OpOverload] = []
+    resolved = []
     for op_name in op_names:
-        overload: torch._ops.OpOverload | None = None
-        candidate_names = [op_name]
-
-        # When the caller omits an explicit overload (e.g. "namespace::op"),
-        # also try the conventional ".default" suffix.
-        if "." not in op_name.split("::")[-1]:
-            candidate_names.append(f"{op_name}.default")
-
-        for candidate in candidate_names:
-            try:
-                op = lookup_op(candidate)
-            except Exception:
-                continue
-
-            # lookup_op may return either an OpOverload (desired) or an
-            # OpOverloadPacket (collection of overloads).
-            if hasattr(op, "overloads"):
-                overloads = list(op.overloads())
-                if "default" in overloads:
-                    overload = op.default
-                elif len(overloads) == 1:
-                    overload = getattr(op, overloads[0])
-                else:
-                    logger.warning(
-                        "Operator '%s' has multiple overloads (%s); please "
-                        "specify the desired overload explicitly.",
-                        candidate,
-                        ", ".join(overloads),
-                    )
-            else:
-                overload = op  # Already an OpOverload
-
-            if overload is not None:
-                break
-
-        resolved.append(overload)
+        try:
+            resolved.append(lookup_op(op_name))
+        except Exception:
+            # Skip operators that don't exist (e.g., model-specific ops)
+            logger.warning(
+                "Failed to resolve operator for Inductor partition: %s", op_name
+            )
 
     return resolved