Arm backend: Shorten pass pipeline logging (#22825)

Modifies 11 passes to only log once rather than once per modification,
as this would lead to unnecessarily long outputs in many cases.


Signed-off-by: Adrian Lundell <adrian.lundell@arm.com>

Author: AdrianLundell

backends/arm/_passes/cast_int64_pass.py

@@ -68,16 +68,12 @@ def _cast_buffer_to_int32(self, node: torch.fx.Node) -> bool:
 
         buffer = store[buffer_name]
         self._assert_within_int32(buffer, node)
-        logger.warning(
-            f"Casting buffer {node.name} from torch.int64 to torch.int32"
-            f" defined in {node.meta.get('stack_trace','[no stack trace found]')}"
-        )
         store[buffer_name] = buffer.to(torch.int32)
         node.meta["val"] = node.meta["val"].to(torch.int32)
         return True
 
-    def _to_int32(self, graph_module: torch.fx.GraphModule) -> bool:
-        modified = False
+    def _to_int32(self, graph_module: torch.fx.GraphModule) -> int:
+        converted = 0
         for node in graph_module.graph.nodes:
             if len(node.users) == 0:
                 continue
@@ -89,11 +85,16 @@ def _to_int32(self, graph_module: torch.fx.GraphModule) -> bool:
             if fake_tensor.dtype != torch.int64:
                 continue
             if is_buffer(self.exported_program, node):
-                modified |= self._cast_buffer_to_int32(node)
-        return modified
+                converted += self._cast_buffer_to_int32(node)
+        return converted
 
     def call(self, graph_module: torch.fx.GraphModule):
-        modified = self._to_int32(graph_module)
+        converted = self._to_int32(graph_module)
+        modified = converted > 0
         if modified:
             graph_module = super().call(graph_module).graph_module
+            logger.warning(
+                "CastInt64BuffersToInt32Pass: cast %d int64 buffer(s) to int32.",
+                converted,
+            )
         return PassResult(graph_module, modified)

backends/arm/_passes/convert_expand_copy_to_repeat.py

@@ -62,6 +62,17 @@ class ConvertExpandCopyToRepeatPass(ArmOpTargetedPass):
     repeat = exir_ops.edge.aten.repeat.default
     target_ops = (expand_copy,)
 
+    def call(self, graph_module):
+        self._removed_noop_expands = 0
+        result = super().call(graph_module)
+        if self._removed_noop_expands:
+            logger.info(
+                "ConvertExpandCopyToRepeatPass: removed %d redundant "
+                "expand_copy operator(s).",
+                self._removed_noop_expands,
+            )
+        return result
+
     def call_operator(self, op, args, kwargs, meta):
         if op not in self.target_ops:
             return super().call_operator(op, args, kwargs, meta)
@@ -71,7 +82,7 @@ def call_operator(self, op, args, kwargs, meta):
         if all((x == 1 for x in multiples)) and not changes_rank:
             # All dimensions/repetitions occur only once. Remove node
             # altogether since it's in practice just a copy.
-            logger.info("Found redundant expand node (no-op). Removing it.")
+            self._removed_noop_expands += 1
 
             return args[0]
 

backends/arm/_passes/convert_int64_const_ops_to_int32.py

@@ -45,6 +45,8 @@ class ConvertInt64ConstOpsToInt32Pass(ArmPass):
 
     def call(self, graph_module: torch.fx.GraphModule):
         modified = False
+        converted = 0
+        skipped = 0
         for node in graph_module.graph.nodes:
             if node.op != "call_function":
                 continue
@@ -61,21 +63,23 @@ def call(self, graph_module: torch.fx.GraphModule):
 
             min_val, max_val = torch.min(data), torch.max(data)
             if INT32_MIN <= min_val and max_val <= INT32_MAX:
-                logger.warning(
-                    f"Casting {node.name} from torch.int64 to torch.int32"
-                    f" defined in {node.meta.get('stack_trace','[no stack trace found]')}"
-                )
                 node.update_kwarg("dtype", torch.int32)
                 modified = True
+                converted += 1
             else:
-                logger.warning(
-                    f"[{node.name}] has values: min={min_val}, max={max_val}, which exceeds int32 range "
-                    f"([{INT32_MIN}, {INT32_MAX}]); not converting dtype to int32."
-                )
+                skipped += 1
 
         if modified:
             graph_module.graph.eliminate_dead_code()
             graph_module.recompile()
             graph_module = super().call(graph_module).graph_module
 
+        if converted or skipped:
+            logger.warning(
+                "ConvertInt64ConstOpsToInt32Pass: cast %d constant operator(s) "
+                "to int32 and skipped %d outside the int32 range.",
+                converted,
+                skipped,
+            )
+
         return PassResult(graph_module, modified)

backends/arm/_passes/convert_int64_output_ops_to_int32.py

@@ -148,11 +148,8 @@ def _convert_casting_operators(self, node: torch.fx.Node):
         if input_dtype == torch.int32:
             users = [user for user in node.users if node != user]
             for user in users:
-                logger.warning(
-                    f"Removing int32->int64 casting node {node.name} defined in"
-                    f" {node.meta.get('stack_trace','[no stack trace found]')}"
-                )
                 user.replace_input_with(node, input_node)
+            self._removed_casts += 1
         # Case 2: other types -> int64 - rewrites to cast to int32
         else:
             if node.target in self.cast_ops_kwargs:
@@ -161,11 +158,7 @@ def _convert_casting_operators(self, node: torch.fx.Node):
                 set_node_arg(node, 1, torch.int32)
             else:
                 raise RuntimeError(f"Unexpected target {node.target} in {node.name}")
-            output_dtype = get_first_fake_tensor(node).dtype
-            logger.warning(
-                f"Converting casting node {node.name} from {input_dtype}->{output_dtype} to"
-                f" {input_dtype}->torch.int32 defined in {node.meta.get('stack_trace','[no stack trace found]')}"
-            )
+            self._converted_casts += 1
 
     def _range_fits_int32(self, value_range: Tuple[int, int]) -> bool:
         return -self._INT32_MAX - 1 <= value_range[0] and (
@@ -471,15 +464,25 @@ def _cast_safe_index_paths_to_int32(
                     )
                     user.replace_input_with(node, boundary)
 
-        logger.warning(
-            f"Inserting a casting node {cast_to_int32.name} after "
-            f"{source.name} for range-safe index consumers defined in "
-            f"{source.meta.get('stack_trace','[no stack trace found]')}"
-        )
+        self._safe_index_casts += 1
         return True
 
+    def _log_summary(self) -> None:
+        if self._removed_casts or self._converted_casts or self._safe_index_casts:
+            logger.warning(
+                "ConvertInt64OutputOpsToInt32Pass: removed %d int32-to-int64 "
+                "cast(s), rewrote %d cast(s) to int32, and inserted %d "
+                "range-safe index cast(s).",
+                self._removed_casts,
+                self._converted_casts,
+                self._safe_index_casts,
+            )
+
     def call(self, graph_module: torch.fx.GraphModule):
         modified = False
+        self._removed_casts = 0
+        self._converted_casts = 0
+        self._safe_index_casts = 0
         graph = graph_module.graph
         for node in list(graph.nodes):
             if node.op != "call_function":
@@ -523,4 +526,6 @@ def call(self, graph_module: torch.fx.GraphModule):
             graph_module.recompile()
             graph_module = super().call(graph_module).graph_module
 
+        self._log_summary()
+
         return PassResult(graph_module, modified)

backends/arm/_passes/decompose_asin_and_acos_pass.py

@@ -27,6 +27,7 @@
 # For MI case
 edge_asin_op = (exir_ops.edge.aten.asin.default,)
 edge_acos_op = (exir_ops.edge.aten.acos.default,)
+logger = logging.getLogger(__name__)
 
 
 def get_decomposition(op) -> tuple:
@@ -73,6 +74,17 @@ class DecomposeAsinAndAcosPass(ArmOpTargetedPass):
     }
     target_ops = edge_asin_op + edge_acos_op
 
+    def call(self, graph_module):
+        self._approximated = 0
+        result = super().call(graph_module)
+        if self._approximated:
+            logger.info(
+                "DecomposeAsinAndAcosPass: approximated %d asin/acos operator(s); "
+                "small numerical errors may be introduced.",
+                self._approximated,
+            )
+        return result
+
     def _build_polynomial(
         self, coefficients: list[float], variable: torch.Tensor, meta: dict[str, str]
     ) -> torch.Tensor:
@@ -124,9 +136,7 @@ def call_operator(self, op, args, kwargs, meta):
             # If quantized, node should be replace by table op
             return super().call_operator(op, args, kwargs, meta)
 
-        logging.info(
-            f"Approximating {op}. This may introduce small numerical errors. For details, see {__file__}."
-        )
+        self._approximated += 1
         x = args[0]
         half = 0.5
         one = 1.0

backends/arm/_passes/decompose_atan_pass.py

@@ -19,6 +19,7 @@
 
 
 edge_atan = exir_ops.edge.aten.atan.default  # MI case
+logger = logging.getLogger(__name__)
 
 
 def _get_atan_ops(op):
@@ -51,6 +52,17 @@ class DecomposeAtanPass(ArmOpTargetedPass):
     }
     target_ops = (edge_atan,)
 
+    def call(self, graph_module):
+        self._approximated = 0
+        result = super().call(graph_module)
+        if self._approximated:
+            logger.info(
+                "DecomposeAtanPass: approximated %d atan operator(s); "
+                "small numerical errors may be introduced.",
+                self._approximated,
+            )
+        return result
+
     def _rational_approximation(self, z, ops, meta):
         """Creates a (2,1) Padé approximation for atan(x) on [-1, 1]."""
 
@@ -85,9 +97,7 @@ def call_operator(self, op, args, kwargs, meta):
             # If quantized, node should be replace by table op
             return super().call_operator(op, args, kwargs, meta)
 
-        logging.info(
-            f"Approximating atan. This may introduce small numerical errors. For details, see {__file__}."
-        )
+        self._approximated += 1
 
         ops = _get_atan_ops(op)
         (

backends/arm/_passes/decompose_log1p_pass.py

@@ -17,6 +17,9 @@
 from executorch.exir.pass_base import ExportPass
 
 
+logger = logging.getLogger(__name__)
+
+
 class DecomposeLog1pPass(ArmOpTargetedPass):
     """Decompose log1p into a small polynomial with a log fallback for larger
     inputs.
@@ -34,6 +37,17 @@ class DecomposeLog1pPass(ArmOpTargetedPass):
     }
     target_ops = _supported_ops
 
+    def call(self, graph_module):
+        self._decomposed = 0
+        result = super().call(graph_module)
+        if self._decomposed:
+            logger.info(
+                "DecomposeLog1pPass: decomposed %d log1p operator(s) via "
+                "polynomial and log branches.",
+                self._decomposed,
+            )
+        return result
+
     def _poly(self, x, meta):
         # 6-term Taylor: x - x^2/2 + x^3/3 - x^4/4 + x^5/5 - x^6/6
         op_mul = exir_ops.edge.aten.mul.Tensor
@@ -71,7 +85,7 @@ def call_operator(self, op, args, kwargs, meta):
             # Quantized log1p should be handled by LUT/table instead of decomposition.
             return super().call_operator(op, args, kwargs, meta)
 
-        logging.info("Decomposing log1p via polynomial + log branch for FP profile.")
+        self._decomposed += 1
 
         x = args[0]
         approx = self._poly(x, meta)

backends/arm/_passes/fuse_constant_ops_pass.py

@@ -219,8 +219,14 @@ def maybe_delete(self, input_nodes_to_maybe_delete):
             if len(input_node.users) == 0:
                 self._delete_constant_placeholder(input_node)
 
+    @staticmethod
+    def _log_summary(fused: int) -> None:
+        if fused:
+            logger.debug("FuseConstantArgsPass: fused %d constant operator(s).", fused)
+
     def call(self, graph_module):
         modified = False
+        fused = 0
         input_nodes_to_maybe_delete = set()
         for node in graph_module.graph.nodes:
             if node.op != "call_function":
@@ -254,11 +260,8 @@ def call(self, graph_module):
             try:
                 did_fuse = self._fuse_nodes(node)
                 if did_fuse:
-                    logger.debug(
-                        f"Fused constant op: {node.name} with placeholder inputs:"
-                        f"{[input_node.name for input_node in input_nodes]}"
-                    )
                     modified |= did_fuse
+                    fused += 1
                     input_nodes_to_maybe_delete.update(input_nodes)
             except Exception as e:
                 logger.warning(
@@ -270,6 +273,8 @@ def call(self, graph_module):
             self.maybe_delete(input_nodes_to_maybe_delete)
             graph_module = super().call(graph_module).graph_module
 
+        self._log_summary(fused)
+
         return PassResult(graph_module, modified)
 
 

backends/arm/_passes/insert_int32_casts_after_int64_placeholders.py

@@ -110,14 +110,12 @@ def _insert_placeholder_i64_to_i32_casts(self, graph_module: torch.fx.GraphModul
                 users = [user for user in node.users if user != cast_after]
                 for user in users:
                     user.replace_input_with(node, cast_after)
-                logger.warning(
-                    f"Inserting a casting node {cast_after.name} after {node.name} to cast int64 placeholder"
-                    f" to int32 for {node.name} defined in {node.meta.get('stack_trace','[no stack trace found]')}"
-                )
+                self._placeholder_casts_inserted += 1
                 modified = True
         return modified
 
     def call(self, graph_module: torch.fx.GraphModule):
+        self._placeholder_casts_inserted = 0
         modified = False
         modified |= self._insert_placeholder_i64_to_i32_casts(graph_module)
         modified |= self._insert_callsite_i32_to_i64_casts(graph_module)
@@ -126,4 +124,10 @@ def call(self, graph_module: torch.fx.GraphModule):
             graph_module.graph.eliminate_dead_code()
             graph_module.recompile()
             graph_module = super().call(graph_module).graph_module
+        if self._placeholder_casts_inserted:
+            logger.warning(
+                "InsertInt32CastsAfterInt64PlaceholdersPass: inserted %d "
+                "int64-to-int32 placeholder cast(s).",
+                self._placeholder_casts_inserted,
+            )
         return PassResult(graph_module, modified)